I started using Kagi because I was tired of digging through ads and SEO spam just to find a straight answer. With Kagi I can actually search again. The interface is clean, the results load fast, and there’s far less noise. It reminds me of the early web – simple and straightforward – while still feeling modern. After a short time it mostly replaced AI chat tools for my search needs, because I’d rather read real sources than risk confident guesses.
What makes Kagi click for me is the focus on the result, not the revenue. I’m not forced to scroll past a wall of sponsored links or affiliate “roundups.” I type what I want and I get useful pages: docs, forums, blogs, papers. That’s the whole point of a search engine, and Kagi gets out of the way so I can reach the information faster.
Modern software development frequently requires coordinating multiple programming languages within a single project ecosystem. In this article I tried to describe the challenges of managing Rust-to-TypeScript workflows and present a solution using Nix flakes, based on patterns observed in real-world development projects.
The examples presented here are hypothetical but derived from actual implementation patterns used in production environments where high-performance Rust libraries are compiled to WebAssembly and consumed by TypeScript frontend applications.
Common Challenges in Multi-Language Development
Projects that combine Rust and TypeScript typically encounter several coordination challenges:
Toolchain Management: Different components require specific versions of Rust, Node.js, and associated build tools
Build Reproducibility: Ensuring consistent compilation results across development, CI, and production environments
Dependency Coordination: Managing the interface between Rust compilation outputs and TypeScript build processes
Environment Consistency: Maintaining identical development setups across team members
Branch Synchronization: Coordinating different versions of core libraries with corresponding frontend applications
Manual Integration Steps: Copying build artifacts between repositories and maintaining build scripts
Traditional approaches using Docker containers, shell scripts, or manual environment management often prove insufficient for addressing the full scope of these coordination challenges.
I started a pet project that combines Rust (for performance and its robust library ecosystem) with Common Lisp (for its interactivity and Condition System), aiming to get the best of both worlds. This setup allows me to build core functionality in Rust and still benefit from the interactive development features and flexibility of Lisp.
Below, you’ll find a brief explanation of how to expose Rust functions and pointers to Common Lisp, and how to set up callbacks from Lisp back to Rust.
I still remember the day I first switched from SVN (Subversion) to Git. It felt like the future had suddenly arrived on my doorstep, offering the power to commit, branch, and merge in ways that SVN couldn’t easily match. Over time, Git became my bread and butter. Now, in 2025 and beyond, I once again find myself on the verge of a version-control transformation—this time by experimenting with Jujutsu.
