A week ago, I wrote about how Coni’s native CSP meets Ollama 0.35’s System One API. The premise was simple: traditional generative LLMs are excruciatingly slow when all you need is a routing decision. By replacing token-by-token autoregressive generation with single-token classification models (like nimble), we achieved instant decision-making and orchestrated massive agent swarms using Coni’s Go-backed Goroutines (spawn) and channels (chan).

And then, SupersonicLabs dropped Julia-1.

Julia-1 is not just another decision model. It is an architectural leap forward: a 144-million parameter bidirectional decision model based on ModernBERT (mmBERT-small). Instead of forcing causal left-to-right attention onto a classification task, Julia-1 evaluates entire prompts bidirectionally with specialized marker tokens, pre-norm transformer heads, and learned type embeddings.

If you’ve been working with LLMs recently, you already know the pain of conversational generation: it’s inherently slow. Waiting for a model to auto-regressively spit out tokens one by one is fine for writing poetry or generating code, but when you’re trying to build autonomous agents that need to make thousands of logical routing decisions a second, traditional chat models are a massive bottleneck.

Enter Ollama 0.35 and the System One API.

Performance optimization is critical, but profiling dynamic languages often comes with a massive caveat: runtime overhead. When dealing with interpreters, developers usually resort to mocking or wrapping functions dynamically at runtime using constructs like with-redefs.

However, when you need your profiler to work flawlessly in both a Native interpreter and Ahead-Of-Time (AOT) compiled WebAssembly environments, dynamic runtime rebinding simply isn’t an option. AOT compilers resolve functions statically.

So, how do you profile an application without modifying the compiler itself or suffering runtime penalties?

In our quest to build a pure, high-performance Lisp ecosystem for the browser, we’ve hit a monumental milestone. Today, we’re showing off our new Infinity 999Hz WebGL application, and more importantly, how it’s completely Ahead-of-Time (AOT) compiled into a native Wasm-GC binary.

As you can see in the screenshot above, the app features a mesmerizing, audio-reactive particle swarm with dynamic magenta and cyan hues, complete with a reactive UI slider to control the color frequency. But the real magic isn’t just on the screen—it’s how the screen is being drawn.

Can you reverse the cube with your mind?

When we look at a rotating wireframe cube, something strange happens. Because there are no depth cues—no shadows, no occlusion, no definitive perspective—our brain is forced to make a choice. Is the front face moving left, or is it moving right? This is known as the Necker Cube illusion, a classic demonstration of bistable perception.

Who says the terminal has to be boring?

Recently, I stumbled across some stunning e-paper displays online. You know the ones—sleek, grid-based layouts showing live stock market numbers and crypto rates. It got me thinking: what if we could replicate that exact aesthetic natively in the terminal using Coni?

As it turns out, it’s not just possible—it’s incredibly easy.

Thanks to Coni’s built-in ui-mount primitive, we don’t have to mess around with raw ANSI escape codes or manual cursor positioning. We just declare our UI state, map it to a layout tree, and let the engine do the heavy lifting!