APRIL 2026 / 24H WINDOW / LIVE 3D GRAPH

The last day of open source AI on GitHub is not a list. It is a graph.

Every SERP result for this query hands you a flat, star-sorted rundown of repos. A 24-hour window on topic like topic:artificial-intelligence is not flat. It is a dense cluster of related events: kernel tweaks that enable model drops, agent frameworks that ship the same day as their underlying runtimes, security patches that cascade through dependency trees. This guide shows how a Mac agent captures that as a real 3D knowledge graph with actual physics, using constants you can read in seven lines of Swift.

M
Matthew Diakonov
10 min read
4.9from Grounded in the Fazm source tree
SIMD3 3D force-directed layout
5 fixed node types, strict enum
100-node visible cap, debounced merges
macOS AX tree, no screenshots
MIT-licensed Mac agent

THE SERP, HONESTLY

What every other page for this query ships

Run the query. Read the top 10. The shape is the same every time: a numbered list of repos with star counts and a one-line description. Useful, but wrong for the question the keyword actually asks. The word releases is plural. The word last day is temporal. The readers who type this are asking how all of that stuff moved together, not which single repo has the most stars.

FeatureTypical SERP roundupFazm: last day as a 3D graph
Shape of the outputFlat list, star-sorted3D force-directed graph
Entity typesOnly repositoriesOrgs, projects, models, concepts
Shows relationshipsNo, only rowsYes, save_knowledge_graph edges
Real-time updateFrozen at publish timeRe-pulled on a schedule
Source ingestionEditor picks, hand-curatedNative GitHub search URL, scoped 24h
Queryable historyN/ALocal fazm.db + graph store
Where it runsPublisher's CMSYour own Mac

THE ANCHOR FACT

Seven lines of Swift that decide how your graph looks

The interesting part of turning "last day 2026" into a visualization is not the LLM. It is the seven lines at the top of Desktop/Sources/MainWindow/Pages/MemoryGraph/ForceDirectedSimulation.swift that set the physics of the layout. You can clone the repo, grep for var repulsion, and change the constants yourself.

Desktop/Sources/MainWindow/Pages/MemoryGraph/ForceDirectedSimulation.swift (lines 49-56)

Why this matters for the last day of GitHub: repulsion is high enough that isolated repos cleanly separate from dense clusters. Attraction is low enough that the connected groups (ollama + gguf + llama.cpp; vllm + DeepSeek-R1 + custom kernel) find each other without collapsing into a point. The center gravity keeps the whole day's activity bounded to one viewable frame rather than drifting off-screen. The simulation settles when stableFramesRequired = 10 consecutive frames move less than 0.2 units. After that, the layout freezes and the clusters are stable.

THE NODE TYPES

Five values. That is the entire ontology.

The save_knowledge_graph tool is declared in acp-bridge/src/fazm-tools-stdio.ts at line 437. Line 454 is the important one. It pins node_type to a strict five-value enum, so the model cannot wander into custom categories when the graph grows. Whatever the day's release list looks like, it maps into these buckets.

acp-bridge/src/fazm-tools-stdio.ts (line 454)
person
Maintainer, tagger, release author
organization
GitHub org (ggerganov, vllm-project, ollama)
place
Discord, HF Hub, a Colab, an RFC
thing
A repo, release tag, model weight file
concept
inference, MoE, quantization, MCP, ACP

THE PIPELINE

From GitHub URL to rotating 3D graph, in one turn

Fazm does not stream an API. It drives your browser, reads the rendered page, and builds the graph in code. The four pieces below are all real files in the repo.

One agent turn, four real pieces of the tree

GitHub search URL
Chrome window
Chat prompt
Fazm agent
AX tree
save_knowledge_graph
ForceDirectedSimulation
MemoryGraphPage

WHAT SHIPS ON A TYPICAL LAST DAY

The 2026 ecosystem, in the rings that matter

Here is the pattern you see when you watch this graph build across a week in April 2026. The center is the pull, the rings are the categories that churned that day. The content of the outer ring changes daily; the inner structure is stable.

topic:ai
last 24h
inference engines
agent frameworks
model weights
MCP servers
ACP bridges
fine-tune recipes
memory systems
eval harnesses

THE DEBOUNCE

Why the graph feels like it "snaps" into place

When the agent parses a daily digest it does not call save_knowledge_graph once. It calls it four or five times, layering orgs, projects, models, edges, and cross-topic concepts. Without the debounce the force simulation would restart on each call and never stabilize. The debounce lives at Desktop/Sources/MainWindow/Pages/MemoryGraph/MemoryGraphPage.swift line 299.

MemoryGraphPage.swift (lines 292-303)
0repulsion constant
0max visible nodes
0ssecond debounce
0node-type enum values

FOUR RULES, FOUR CARDS

Why a graph beats the top-10 list for this query

Edges carry the story

A repo shipping DeepSeek-R1 inference the same day the weights drop is one event, not two. Lists flatten that; a graph shows it as a bound cluster.

Clusters are stable, rows are not

Day over day, the same topic clusters (llama.cpp + GGUF + ollama; vllm + DeepSeek + custom kernels) re-form. Row order changes every hour.

Fixed ontology, messy input

The five node types (person, organization, place, thing, concept) are enforced at the tool boundary, so a sloppy model output still yields a graph you can query.

Local, queryable, forever

The graph lives in KnowledgeGraphStorage and fazm.db. No SaaS, no API quota, no dependency on whatever curated list we trusted last month.

THE RUN

A real chat session, abbreviated

Shape of the turn log when you ask for today's graph. Names and counts below are illustrative; the ratios are what you will actually see.

fazm chat session

THE SETUP

From zero to a daily graph, in five steps

1

Install Fazm

Download the signed DMG from fazm.ai. Drag to Applications. Open. During onboarding, grant Accessibility and Screen Recording permission. Accessibility is how the agent reads the GitHub result list without OCR.

2

Pin the last-day query

In chat: 'remember github.com/search?q=topic:artificial-intelligence+pushed:>YESTERDAY&s=updated as my daily AI release query.' The agent stores it locally and substitutes YESTERDAY automatically at call time in UTC.

3

Dry-run the graph

'Open my daily AI release query, read the top 40 repos, and build a knowledge graph with save_knowledge_graph.' The agent extracts entities and edges and opens MemoryGraphPage so you can watch the simulation relax.

4

Persist the history

'Also append today's repos to fazm.db as ai_releases_daily with columns date, repo, description, stars, pushed_at.' Both stores update together, so you can query rows or traverse edges later.

5

Schedule the recurrence

'Do this every weekday at 8am and show the graph in the sidebar.' Fazm writes a recurring task. Each morning you open the app to a freshly-laid-out 3D snapshot of what the ecosystem did overnight.

EDGE TYPES WORTH KEEPING

Relationships that make the daily graph useful

The tool does not ship a fixed edge-label vocabulary (unlike node types, edges are free-form strings). These are the labels that, in practice, carry the most signal when you re-open the graph a week later.

depends_onforked_fromsame_authorsame_day_releasesame_orgships_modelpatches_cveimplements_mcpimplements_acpruns_onquantized_bybench_againstreplacesmentionsextendswrapsvendorsupstream_ofdownstream_ofcontributed_by
5

A daily release graph is an ontology problem, not an LLM problem. Fix the five node types at the tool boundary and everything else composes.

fazm-tools-stdio.ts line 454

WHY THIS IS UNCOPYABLE

You can read the constants. You cannot paste the experience.

Every number in this page points at a real line in the Fazm repo. Clone github.com/mediar-ai/fazm, open ForceDirectedSimulation.swift, change repulsion from 80_000 to 40_000, rebuild, run. The cluster layout will change in a way a flat list cannot even represent. That is the editorial gap this guide is built on: the question the query asks has a spatial answer, and the spatial answer is a program.

By the numbers, last day, typical 24h

Shape of a representative recent day on topic:artificial-intelligence. Exact numbers move. The graph ratios are stable.

0+
repos pushed in 24h
0
top-slice rows per run
0
edges in a typical graph
0
external APIs in the loop

Want a daily 3D graph of the open source AI ecosystem?

15 minutes on a call and we will wire up a Fazm recurring task that builds your own knowledge graph from the last day of GitHub activity, every morning, on your Mac.

Book a call

Frequently asked questions

What does 'open source AI projects releases github last day 2026' actually return, if you treat it honestly?

Two questions stacked into one. The first half 'open source AI projects releases GitHub last day' is a time-scoped activity query: everything with topic:artificial-intelligence (or topic:llm, topic:agents, topic:ml) that was pushed or tagged in the last 24 UTC hours. The second half '2026' is a year filter, and it matters because the ecosystem in April 2026 is dominated by agent protocols (ACP, MCP), local inference engines (llama.cpp, ollama, vllm, mlc-llm, mistral.rs), open-weight model families (DeepSeek-R1, GLM-5.1, Qwen3, Llama 4, Kimi-Dev-72B), and memory systems (MemPalace, a2a). A list of repos tells you what shipped. A graph of their relationships tells you why, and which nodes move together.

Why turn the last day of GitHub activity into a knowledge graph instead of a list?

Because the interesting question is almost never 'which repo got the most commits,' it is 'which of these releases are related.' A vllm kernel tweak the same day DeepSeek-R1 drops a new checkpoint is one connected event, not two. A CrewAI security patch followed within hours by a downstream release in smolagents is a dependency edge, not a coincidence. GitHub's native search URL returns the nodes for free. The edges have to come from somewhere, which is what Fazm's save_knowledge_graph tool is for. The enum of node types is fixed at exactly five values (person, organization, place, thing, concept) so edges have something to attach to, and the live force-directed layout makes the clusters obvious at a glance.

What are the exact physics constants Fazm uses to lay out the daily release graph?

Read them yourself at Desktop/Sources/MainWindow/Pages/MemoryGraph/ForceDirectedSimulation.swift lines 49 through 56. The defaults are repulsion 80,000, attraction 0.003, centerGravity 0.0008, damping 0.9, dt 0.016 (60 fps), restLength 600, maxSpeed 40. Nodes are SIMD3<Float> 3D vectors, seeded at a random position inside a sphere of radius 200 to 600, and the simulation considers itself stable when 10 consecutive frames fall below a 0.2 movement threshold. The constants retune themselves for small graphs: under a threshold in populate(), restLength drops to 300 and repulsion to 50,000, so a 12-node digest does not fly apart.

How many repos can the live graph actually show before it gets messy?

MemoryGraphPage.swift line 143 sets maxVisibleNodes = 100. That is the cap on what the force-directed view renders, not the cap on what the underlying KnowledgeGraphStorage holds. A typical last-24-hour pull on topic:artificial-intelligence returns on the order of 900 pushed repos and 60 tagged releases, so the agent is expected to rank and slice before it calls save_knowledge_graph. The tool description in fazm-tools-stdio.ts suggests 15 to 40 nodes with meaningful edges. That range is where the 3D layout looks its best.

Where does the 5-second debounce come from and why does it matter for this workflow?

MemoryGraphPage.swift line 299 has a Task.sleep of 5_000_000_000 nanoseconds wrapped inside addGraphFromStorage(). The reason: when a large digest lands, the agent may call save_knowledge_graph 4 or 5 times back-to-back (first the orgs, then the models, then the inference engines, then the agent frameworks, then the cross-edges). Without the debounce the graph view would re-layout after each call and the simulation would never stabilize. The buffer coalesces them into a single performIncrementalGraphUpdate() pass, which is the only thing that preserves the satisfying 'snap into place' feel.

How does the graph get data, if GitHub does not expose a graph API for topics?

The data comes from the same place the flat list does: the rendered GitHub search page. Fazm opens the search URL in Chrome, reads the result list via the macOS accessibility tree, extracts typed fields per repository card, and hands the rows to the model. The model is then prompted to emit entities (orgs, projects, models, concepts) and relationships (depends_on, forks, same_author, same_day_release) and call save_knowledge_graph with the shape. The raw repo rows can also be written to fazm.db via execute_sql for queryable history. The graph is a view over those two stores, not a separate pipeline.

Why is this better than 'awesome-ai' lists or monthly GitHub roundups?

Awesome-lists are human-maintained and lag by days or weeks. Monthly roundups are frozen the moment they publish. GitHub's topic pages sort by stars, so a 2023 repo that has not been touched in a year still sits above a repo that shipped a major release this morning. None of them answers the cross-project question: which projects in the ecosystem shipped together on the same day, and what do they have in common. A daily graph captures exactly that. As a consumer app, Fazm is also not a developer pipeline you have to maintain; install the DMG, grant Accessibility permission, and ask the agent to do it.

What is the difference between 'last day 2026' and 'past 24 hours' as a query?

Semantically almost the same thing, but people who type 'last day 2026' are often asking one of three variations: the last 24 UTC hours, the last full calendar day in their timezone, or the final day of a named period like 'the last day of April 2026.' The GitHub URL pattern handles all three with different date inputs. Fazm resolves the intent in chat. If you say 'the last day,' it defaults to yesterday UTC. If you say 'the last day of April,' it builds a query for 2026-04-30. Either way the output is a graph with today's release activity clustered around stable anchor nodes.

Do I need to understand graph theory, accessibility trees, or Swift to use this?

No. Fazm is a consumer Mac app. You open the chat and say 'get the last day of open source AI releases from GitHub and show me the graph.' The agent handles the URL, the AX tree read, the entity extraction, the save_knowledge_graph call, and the 3D layout. The five node types are enforced by the JSON schema in fazm-tools-stdio.ts so the model cannot emit ambiguous types even if it wanted to. You watch the graph form in the MemoryGraphPage window while the simulation relaxes.

Is Fazm itself open source, given the topic of this page?

Yes. Repository is github.com/mediar-ai/fazm. License is MIT. The Swift desktop app lives under Desktop/, the Node ACP bridge under acp-bridge/. Every file this page cites (ForceDirectedSimulation.swift, MemoryGraphPage.swift, fazm-tools-stdio.ts, ChatPrompts.swift) is in that tree. Fazm itself shows up on your daily topic:artificial-intelligence pull whenever we push, which is a fun recursive property: the tool you use to visualize the ecosystem is a node inside the visualization.