• 3 posts
  • 29 comments
Joined 4 months ago
Cake day: February 23rd, 2026
  • haha the idea comes from the fact that the tool is not opinionated - in the sense that yes its an API client but its also an editor, etc. So it a tool with infinite possibilities and can be as flexible as people want. So this is the idea: void-endlessness-freedom.

    If it didn’t scare you alot, will you try it? :)

Wanted to provide an update around the CLI runner that we shipped a few days ago. This was already on beta for quite some time so now that its on stable, I thought of giving it another go in the community.

For those who are not familiar with the tool and what the h#$@ I am talking about: Voiden is an offline, git-native API tool built on Markdown.

We built it (and then open sourced it) because API tooling sucked (and we work a lot of APIs enough to care to do something about it). I will just name a few issues: cloud dependencies, forced accounts, proprietary formats plus many more.

Long story short, this is Voiden: instead of keeping API requests inside a cloud workspace, Voiden stores them as .void files that can live with your codebase, be versioned in Git, reviewed in PRs, and reused across a team. Plus everything is plain executable markdown. By “everything” I mean really everything: API specs, tests, docs, context…everything.

We have now released the @voiden/runner, which is a headless CLI for running those .void files outside the desktop app.

The runner executes the requests, prints the results, and exits with a standard exit code that CI systems can use.

Things to note:

  • runs on Node.js 18+
  • works in terminal, CI/CD, Docker, and cron jobs
  • supports REST, WebSocket, gRPC, and GraphQL
  • supports request chaining through runtime variables
  • works with core Voiden plugins like scripting, assertions, faker, advanced auth, + more.

The ultimate goal is to make .void files executable API workflows, not just files used inside the desktop app.

The Github repo: https://github.com/VoidenHQ/voiden

Voiden CLI Runner : https://github.com/VoidenHQ/voiden/tree/beta/packages/voiden-runner

Visit Voiden here : https://voiden.md/

P.S this post is mainly around the Runner but every feedback outside that is also welcome, especially coming from any postman or insomnia power users in the room :)

  • hm…great points, thanks for taking the time to answer.

    From the perspective of a user, why would they care about development speed?

    Yes, the tool is already developed but it will continue evolving right? I mean, we almost make 2-3 releases every month since we shipped the first version and then open sourced. So the speed still counts. Plus, the users who create the tickets and expect them to be tackled are actually developers themselves. So yeah, the ability to deliver (at a good pace) to these folks matters a lot.

    However - YES, if at some point the tool is at a state that the speed becomes less meaningful or useful, then indeed a change might be needed?

    As for platform consistency, again, why would the user care?

    Yes, since our users are Dev (and QA) folks, we thought that yeah, maybe someone could have different systems for work vs home vs side project (as you said). But another aspect that we thought is teams and collaboration. We didn’t want to have a scenario in which a team can not use it before some of the devs are using macs, others linux vs the QA folks using windows etc.

    What I’m getting at is that the concerns of developers will not always be equally concerning to users.

    Thats the heart of the discussion:) I guess because our users are also developers. :)

Hello,

I am writing cause I wanted to get some opinions from folks here that have actually built and shipped with Electron (or Tauri).

Background: Building an API IDE on Electron. Not really “just an API client”, and not a(nother) thin wrapper around a webapp either. It’s a pretty original desktop tool with a lot of editor/IDE-like behavior - not the typical form centric behavior that postman or others have: local workflows, richer interactions, and some things that honestly would have been much harder for us to build and iterate on this quickly in a more constrained setup. Thats why Electron.

this is the tool: github.com/voidenhq/voiden

Now, as adoption is growing, we are starting to get the usual questions about memory footprint and app size.

The (slightly) frustrating part is this:

When the app is actually being used, the app-side memory is often pretty reasonable. In many normal cases we are seeing something like 50–60 MB for the actual usage we care about (even added it in the app itself for people to check it out).

But then people open Activity Monitor, see all the Chromium/Electron-related processes, and the conversation immediately becomes:

“yeah but Tauri would use way less”

And then, without realizing, I suddenly end up talking and philosophizing about Electron, instead of discussing the tool itself (which is what I am passionate about :)

And of course, I get it. The broader footprint is real. Chromium is not free. Electron has overhead. Pretending otherwise would be foolish. So we are constantly optimizing what we can, and we will keep doing so…

At the same time, I do feel that a lot of these comparisons feel weirdly flattened. For example people often compare:

full Electron process footprint VS the smallest possible Tauri/native mental model

…without always accounting for development speed, cross-platform consistency, ecosystem maturity, plugin/runtime complexity, UI flexibility, and the fact that some apps are doing much more than others. Which is by the way the reason that we went with Electron.

So all this context to get to my real question, which is:

  • How do you explain this tradeoff to users in a way that feels honest and understandable, without sounding like you are making excuses for Electron?

And also, for those of you who have had this conversation a hundred times already:

  • What do you say when people reduce the whole discussion to “Electron bad, Tauri good”?

  • Have you found a good way to explain footprint in practical terms?

  • Where do you think optimization actually matters, vs where people are mostly reacting to the idea of Electron?

Mostly trying to learn how others think about this , especially those who have built more serious desktop products and had to answer these questions in the wild.

Would love your thoughts and advice!

  • hey - thats great :) Happy you downloaded it :) curious to hear your feedback - I will send you a discord link as a message so its not seen as spamming.

    Let me see if I understand your question: you mean how Voiden would look when its more mature?

    What I am most excited about is that Voiden already does a few things differently from most API tools. Reusable blocks, plain-text everything, and the ability to go from testing to docs to publishing from a single source are already working and shaping how teams can work in a more consistent way.

    There is still a lot ahead (for example I want to see what kind of plugins people come up with for the tool, or how AI will eventually play a bigger role) but the principles of Voiden (reusability, composability, plain text, collaboration through git, single source of truth etc.) are the ideas I believe will define and set a new tone/standard of how API tools should be.

  • haha indeed - modern has this “blinking lights” connotation. something that is shiny.

    True story - once, in primary school, I went to a halloween party, where all the boys were dressed as batman and all the girls as macarena (guess my age). The host of the party was maybe the only one not dressed as batman.

    He was wearing some weird jell in the hair, like a punk kind of thing, with a lot of strass, stars all over his body, some heart or thunder shaped big mirror glasses, a shiny jacket and the best looking blue mocasines I have ever seen. He also had a big radio antenna (??) coming through his nylon electric yellow vest.

    I asked him: what are you dressed as? and he replied: “Modern”.