Intro

A year has passed and I haven’t posted anything to this blog. How time flies. I realized that my tooling has changed quite a bit (at work and at home). I’m not allowed to describe the work tooling but I can definitely describe the new tooling I use at home. This post is just that. It will cover all use cases: Go, C++, Haskell, Python, math typesetting and blogging. As it turns out, I’m using the same (new) tooling for all use cases.

As always, this post is mostly for me, documenting my setup. Feel free to adopt it only partially, adjust it, modify it as needed. Swap out Antigravity for your favorite VSCode fork 🙂.

Ditched

To be clear, ditching is not a value judgement on the tools I no longer use. They are excellent. I just simplified and unified. Ok, what got ditched:

Antigravity

My new choice for IDE is Antigravity. Antigravity is a VSCode fork with minimal default extensions installed and with Open VSX as the default extension marketplace. For obvious reasons I’m very familiar with the UI. As we will see, it handles all my use cases (Go, C++, Haskell, Python, math typesetting and blogging).

And yes, I am still using an IDE. I am not ready to move into Gas Town 🙂.

tourist in gas town

These are the extensions I have installed:

The list is not surprising given my use cases. I use bazel as my build system, again because of familiarity from work. I use it for most use cases (blogging and Haskell are the exceptions).

I wanted the native Apple clang C++ toolchain for C++ and the only thing missing was a good debugging UI. Luckily CodeLLDB exists.

For math typesetting the big change is that I moved away from LaTeX to Typst.

Let’s go over the use cases one by one, from simple to C++.

Python

Not much to say here. All standard VSCode stuff.

Go

Antigravity comes with Go support. As far as I remember, I didn’t have to do anything. Not sure if all VSCode forks have these batteries included. I already had delve installed and the debugging UI just works. I don’t think I needed anything special for the language server gopls, it comes with Go.

Haskell

Not much changed. My previous setup was using VSCode, so Antigravity works the same.

Blogging

Hugo is all markdown and Antigravity/VSCode supports it. I got rid of the custom previewing inside the IDE. It’s not a big deal to have an outside Chrome window open with the local blog rendering and a terminal window running hugo server --buildDrafts.

Math typesetting

I recently gave Typst a spin and immediately got hooked. The simplified syntax (compared to LaTeX’s syntax), the straightforward support for custom functions and the rendering speed are irresistable. With the latest release it supports embedding PDF images (a feature missing previously). And then there’s Tinymist which allows doing it all in Antigravity, with instant rendering preview that makes jumping back and forth between preview and corresponding markup text a breeze.

For building the PDFs I use bazel rules:

load("//:typst.bzl", "typst_document")

typst_document(
    name = "example",
    main = "example.typ",
)

The file typst.bzl defines the custom bazel rule typst_document:

def _typst_document_impl(ctx):
    output = ctx.actions.declare_file(ctx.attr.name + ".pdf")
    input = ctx.file.main

    args = ctx.actions.args()
    args.add("compile")

    # args.add("--root", input.dirname)
    args.add(input.path)
    args.add(output.path)

    ctx.actions.run(
        outputs = [output],
        inputs = [input],
        executable = "typst",
        arguments = [args],
        mnemonic = "TypstCompile",
        use_default_shell_env = True,
    )
    return [DefaultInfo(files = depset([output]))]

typst_document = rule(
    implementation = _typst_document_impl,
    attrs = {
        "main": attr.label(allow_single_file = [".typ"], mandatory = True),
    },
)

C++

The constant trouble child of programming environments is C++ (well, at least for me). At work I have an army of motivated engineers making it all work seamlessly. No such luxury at home. I wanted the Apple clang toolchain and bazel. The bazel part has progressed nicely, the registry is fairly complete for my needs. The bazel extension works well. So what is the problem? Well, I wanted to switch from MS C++ extensions to clangd and have build and debug support. This is the point where Gemini and Antigravity come in and save the day. I basically let Gemini inside Antigravity set it up for me. I only told it to use agy instead of code when issuing VSCode commands in the terminal, so it can operate on itself. I have an example project and Gemini was tasked to come up with all the bazel and VSCode setup files needed to run and debug the GoogleTest unit test in the project. I cannot say I contributed much other than approve the terminal commands it wanted to execute. You can check out the result. Not sure how portable the setup is but it does work for me with the Apple clang toolchain and bazel installation.

Git

A short word about the version control UI in Antigravity. I find it refreshingly simple for one-person hobby projects (commit and sync). Also I’m slowly transitioning away from Github to Codeberg (I know, I’m an old guy trying to stay cool ¯\_(ツ)_/¯).

Vibe coding

So did I embrace the LLMs and do vibe coding 🙂? I’m not sure if how I use Gemini inside Antigravity qualifies, but I do let Gemini correct errors in the build setup for example. I let it write more unit tests after I write a couple and tell it to complete the coverage. I let it explain various errors or look up some syntax (especially in typst which is still fairly new to me). I appreciate the nice integration of Gemini and Antigravity. So there you go: tooling.