is a rootless, single-binary Nix runtime built on Δ-Nets — interaction nets with optimal λ-reduction and perfect confluence. It delivers reproducible builds and verifiable computation with no root and no /nix: one engine that builds packages, evaluates multiple languages by their computed meaning, and machine-checks proofs from its own theorem-proving kernel.

It's years of research becoming real software — my most ambitious work to date, and the work that most needs your support to reach its full potential.

• Sponsor me on GitHub — recurring support; the single biggest help toward going full-time on open source.
• Donate on Ko-fi — a one-off thank-you whenever something I made saved you time.
• Commission OpenSource work — want me to contribute to a specific project? Let's talk.
• Leave a potato 🥔 — or literally anything else. Just say "Hey, here's a potato."

If Denful or any of my libraries save you time, supporting the person behind them is what lets me keep building them in the open. 🙏

A suite of small, composable, mostly zero-dependency libraries. Each solves a specific problem and works on its own or together with the rest. You can also browse everything I've been shipping lately.

• — Context-aware, aspect-oriented Nix configuration framework. Declarative pipelines, host/user schemas, batteries included.
• — The foundation: zero-dependency aspect composition with transposition, dependency DAGs and parametric providers.
• — Recursively import every Nix module in a tree. The most widely adopted library in the ecosystem.
• — Generate flake.nix from typed Nix module options. Input & output schemas.
• — Community-driven Nix distribution built on the Dendritic pattern.
• — Dendritic Nix without flakes or flake-parts.
• — Zero-dependency flake checker: treefmt + nix-unit for testing other flakes.
• — A flake-inputs adapter for Nix projects that don't use flake.nix.

• — Algebraic effects system with handlers for Nix, built from four kernel primitives.
• — Ability-style algebraic effects for stable Rust, modeled after Scala's Kyo. (Research)
• — An algebraic effect-handler system for Go with typed capabilities.
• — A freer-monad effect layer with an MLTT dependent type checker, for stable Rust.
• — Core contributor: effect system with dependent & linear types and a HOAS checker for Nix.

• — Stream-based functional-reactive programming for Nix, inspired by Cycle.js.
• — Message-passing actor system for pure Nix, built on ned stream-cycles.
• — Minimal stream-based Nix module system. ~100-line kernel, MLTT-verified, ~26× faster than lib.evalModules.
• — Lens-based bidirectional parser-combinators for Nix. Parse, don't validate.

• — Rootless, single-binary Nix runtime on a Δ-Nets optimal-reduction engine. (Sponsor →)
• — A Nix language compiler into Delta Interaction Nets. (Research)
• — A Go implementation of Delta Interaction Nets — reduction engine & compiler backend. (Research)
• — A Nix language parser implemented in C (ragel + bison). (Research)

• — Find nixpkgs revisions for historical package versions + a minimalist Nix version manager.
• — Declarative multi-node NixOS fleets with a CSS mental model: traits, selectors, DOM-style targeting.
• — Parallel, nix-unit-compatible test runner via nix-eval-jobs.
• — My multi-host NixOS + Darwin Dendritic infra — the proving ground for the whole ecosystem.
• — I've been contributing to this awesome jj TUI.

For a full list, see my GitHub repositories.

Everything I know, I've learned by reading other people's code — I believe in the power of sharing knowledge. I create tools and languages that empower developers by making their work more productive, reliable, and enjoyable. My passion is building robust, real-world solutions with functional programming, effect systems, and language implementation.

A deeper catalog of original work, spanning several languages and ecosystems.

• — Context-aware, aspect-oriented Nix configuration framework.
• — Import all Nix files in a directory tree. The ecosystem's most adopted library.
• — Zero-dependency aspect composition with dependency DAGs.
• — Community-driven Nix distribution.
• — Generate flake.nix from typed module options.
• — Algebraic effects with handlers for Nix.
• — Minimal stream-based module system, ~26× faster than lib.evalModules.

• — μKanren-inspired relational/logic programming for ZIO2.
• — Minimalist distroless Docker images for Java apps using Mill.
• — Immutable double linked list in Scala 3.
• — Giter8 launcher for scala-cli.
• — Cycle.js style user-computer model in Laminar.
• — Scala 3 compiler plugin to prevent unsafe function calls.
• — Logic programming language based on typed concatenative effects (Scala prototype).
• — Define big project structures as a regular Scala project.
• — Functional-reactive interfaces on Laminar and Scala.js.

• — Ecto-style parameter validation/casting.
• — Macro for extracting/transforming values in pipe flows.
• — Macro to avoid commas in Elixir's with special form.
• — Data specification conformance and generation.
• — Reusable, composable patterns across Elixir libraries.
• — Pipe Elixir functions that match ok/error tuples or custom patterns.
• — State-aware Elixir functions without spawning processes.
• — Minimalist function decorators for Elixir.
• — Macro for easily piping arguments at any position.
• — The alchemist's happy path with Elixir.
• — Indifferent access on maps/lists/tuples with custom key transforms.

• — The purple turtle theme for Spacemacs.
• — Vic's Emacs Environment.
• — Better fuzzy matching for Emacs ido-mode.
• — Set Emacs color themes by buffer.
• — Let Emacs suggest which key bindings to press.

• — Search Nix package versions and minimalist devshell/version manager.
• — Vim/Evil leader-key for your $SHELL.

• — Rootless, single-binary Nix runtime on a Δ-Nets optimal-reduction engine.
• — Ability-style algebraic effects system for stable Rust.
• — Freer-monad effects with an MLTT dependent type checker.

• — Send keyboard macros to Spacemacs or DOOM Emacs via emacsclient.
• — Create reusable Docker layered images from Java fat-jar apps.
• — Deploy Nim applications to Heroku.
• — Git-based server provisioning.

• Buildr — Core contributor and Apache Software Foundation member; Project Management Committee chair.
• asdf-vm — Maintainer and plugin author for the extensible version manager.
• Rubinius — Early contributor to the Ruby VM.
• Ragel — State-machine compiler: early contributor of Ruby and Rubinius VM code backends.
• Darcs — My early contributions to open source.
• vtd-xml — Contributed patches to the streaming parser.
• Fancy Language — Contributor to a dynamic, functional OO language.
• Typhon — Python implementation for the Rubinius VM.
• effects-bibliography — Collaborative bibliography of computational effects.

I'm doing lots of Nix, Scala 3, Go and Rust — and I love creating stuff for people like me: nerds.

• I love poetry, Rothko paintings, the Rebecca purple color, and effect systems.
• I'm a Seventh Day Adventist. I enjoy our Sabbath School so much — self-reflecting, learning lessons from the Bible that teach me about the real character of God and the love he gives us to give.
• I enjoy reading about religions, theology, physics, math (mainly related to C.S.), type theory, and effect systems.
• I have a ~50% hearing disability, so I prefer to communicate via async written form whenever possible.
• I love customizing my Glove80 keyboard and finding layout optimizations that reduce finger stress.
• I'm single — send a pull request fixing this. 😄

I believe my life has a purpose. And that purpose, for me, is Love.

I believe that we are not the authors of Love, but that Love has authored us. And as much as we are willing to receive it (God/Love), we will also be able to give it to others.

None of us is perfect and we have all done wrong, but there is so much more to life than only our past. Learn, change, adapt, become a better person every single day.

So, having a purpose in life, for me, means having the willingness to be transformed by Love and to be able to give it to others.

• Functional programming (Scala, Haskell, Elm, Elixir)
• Effect systems and concurrency models
• Compiler and language implementation (Scala, Rust, Go, Ruby, Python)
• Nix and reproducible developer tooling
• Open source leadership and community building

I'm always open to remote opportunities. I love working on developer tools, compilers, effect systems, and Nix-infrastructure tooling. Nowadays I prefer Nix, Elm, Scala 3, Rust and Go.

If you're building something in compiler/language implementation, effect systems, developer tooling & infrastructure, or functional programming — let's connect.

📄 Read my CV — 25+ years across developer tooling, effect systems, compilers, and functional programming.

• 💬 Open a discussion for an open conversation about anything — I'd love to hear about you.
• ✉️ vborja@apache.org — for business (and spam).
• 🦋 oeiuwq on Bluesky
• 𝕏 oeiuwq on X

Feel free to reach out if you'd like to collaborate, discuss opportunities, or just talk about common interests and projects.

GitHub User #331

💜 Sponsor my work and help me build dnx full-time.