d2

If Marie Kondo were a programmer, d2 would be her favorite developer tool. This program sparks so much joy.

d2 is a text-based diagramming program that is easier and faster to write and prettier to look at than all its competitors. Don’t believe me? The team behind d2 also put together a site for head-to-head comparisons with alternatives.

I’ve used it in my READMEs, I use it at work, I use it whenever I can. I cannot endorse it enough. Here’s an example: If I want to create the SIP call flow from RFC 3261, I can do it in a matter of minutes.

Without any custom styling, I can write a sequence diagram like this:

direction: right
shape: sequence_diagram

a: Alice
ap: atlanta.com proxy
bp: biloxi.com proxy
b: Bob

a -> ap: INVITE F1
ap -> bp: INVITE F2
ap -> a: 100 Trying F3
bp -> b: INVITE F4
bp -> ap: 100 Trying F5
b -> bp: 180 Ringing F6
bp -> ap: 180 Ringing F7
ap -> a: 180 Ringing F8
b -> bp: 200 OK F9
bp -> ap: 200 OK F10
ap -> a: 200 OK F11
a -> b: ACK F12
a <-> b: Media Session
b -> a: BYE F13
a -> b: 200 OK F14

Which generates this diagram (yes, it’s a bit tall):

It’s pretty obvious how the code works, and even without any custom styling, the diagrams look great. Flat code like this also plays great in version control, which is a primary driver for text-based diagramming tools in the first place. Give it a spin sometime - If you don’t want to install the binary, you can always use the WASM version.

Neovim

It’s probably telling that I originally started this section with “Look, I’m not trying to argue.” But that’s not entirely true: I am trying to argue…with myself as of a few months ago.

What do I mean by properly configured?

1. Use Lua. You can do it, I promise. (Shoutout to Robbie for encouraging me to do it myself!)
2. Set up lazy.nvim. I’ve tried a few Neovim plugin managers; this one is the best.
3. Set up some language server protocol implementations. With LSP implementations like pyright, you get most of the interactivity of an IDE right in your vim session. This takes some upfront cost to configure, but once you have them, developing is a breeze. This is so essential I think it supersedes tinkering around with any other plugins.
4. Tinker around with other plugins! Come on, you knew this was coming. Right now, I mostly just use conform for file formatting. Unlike with my old vimscript-based configuration, though, it is so simple for me to try out new plugins that I can mix and match in a matter of minutes with only a few lines of code.

For a simple example of how to set lazy.nvim and manage LSP implementations and other packages, see my dotfiles or search around for other reference implementations.

Obsidian

The bar is damn high. Obsidian raises it. Oh, and it’s now free for professional use, too.

The plugin ecosystem is more important here than it is for me with Neovim. Right now, I use a few plugins together to maintain a daily note directory, where each day gets its own types of notes: meetings, coding, messages, and documents. I love using folders to organize these; I find it much clearer to have one note per meeting than to try to collate and classify my thoughts while I’m recording them.

The big idea here is to use the tasks plugin to surface all TODO items from any of these documents into one place. This creates a sort of dashboard for my thoughts and words. For now, it looks like this:

If this sounds interesting to you, I’ve published an example vault that you can try out for yourself (once you install the required plugins).

I will say I’m definitely not an expert here yet. I want to get better at linking information conceptually once I’ve actually recorded it.

uv

uv makes the worst parts of Python painless. It is blazing fast, simple, and excellent. uv venv and uv pip install are two of my most-run commands. Use it, cherish it, spread the good news to your friends and family. Here’s a great article if you’re looking for a place to start.

pytest

I was years into writing Python before I wrote my first pytest test. It was years after that I learned how to use pdb. I did not know, until a month ago, that these two things can go great together. Run pytest --pdb to launch an interactive debugger within your test session. You can even set a lazy breakpoint in your code without imports with a quick assert False. This is incredible, and plays so well to Python’s strengths. A few dir() calls here and there and I can write tests an order of magnitude faster than I could before.

I also want to mention how many powerhouse fixtures come baked right into the framework: caplog for testing logging, capsys for testing other side effects, and tmpdir for making temporary directories have become some of my most-used tools.

ripgrep and fd

When I started programming professionally, I never imagined using the command line. I pictured a solitary, well-defined codebase that I’d primarily work with through one lanugage-specific IDE. I have seen enough now that I don’t think code like that exists.

Using the command line can feel intimidating. I think that’s arguably intentional: We’re reliant on dozens of tools built decades ago with minimal, if not hostile, user interfaces. There’s work being done to make this a better experience for everyone, though. Hopping between directories and getting your bearings is made so much easier with the implausibly fast ripgrep. ripgrep searches all the files under your current directory for a given string, just like grep -R. It’s a powerful tool for finding uses of classes, hunting down an error, and even searching your notes. Start using it and you won’t stop.

fd also gets a mention here too, as basically ripgrep for files. It deserves bonus points because it is so much easier to use than vanilla find. I often find myself dancing between the two, spitting out quick searches so fast that I might as well be in a fine-tuned IDE.

jq, yq, and difftastic

If you find yourself working with JSON, you won’t regret learning some basic jq. jq is a query system for JSON objects, providing a lot of functionality for working with JSON without firing up a programming language. yq is, in my opinion, primarily useful for converting YAML into a reasonable format (JSON). Use yq -r <file.yaml> -o j | jq to make sense of the world’s strangest templating language.

I want to mention difftastic here, too, because I’m often using it in conjunction with jq --sort-keys to compare highly nested data - JSON, YAML, etc. This is a really powerful workflow that will save you from writing a lot of repetitive scripts. Also, difftastic makes for much better git diffs.

Liftosaur

Okay, okay, okay. I know this post is about “developer tools” I use in 2025, but I have to end with my weight training app. Liftosaur is a weight tracking app for coders. Features include:

• A beautiful, simple syntax for structuring workout splits and progressions
• Open source code
• The option to self-host backups
• A cute dinosaur mascot(!)

Cuteness aside, you can see the website for the great UI of this app. I’m going to focus here on the ability to program workouts.

Here’s a subset of my current split, presented as code (do NOT pay attention to the weights please 🙈)

# Week 1
## Upper #1
Seated Row, Leverage Machine / 3x8-10 / 110lb / warmup: 1x10 45lb / progress: lp(5lb)
// Use small bar, overhead. Lean into it. Get stable before you start the lift
Triceps Extension, Cable / 2x8-10 / 57.5lb / warmup: 1x5 20lb / progress: lp(5lb)

## Leg #1
Seated Leg Curl / 3x8-10 / 160lb / warmup: 1x10 80lb / progress: lp(5lb)
Hip Abductor, Cable / 3x10-12 / 20lb / warmup: 1x10 10lb / progress: lp(5lb)
Seated Leg Press / 1x4, 1x6, 1x8 / 240lb / warmup: 2x10 150lb / progress: lp(5lb)
// 2-3s negative
Leg Extension / 3x10-12 / 140lb / warmup: 1x10 100lb / progress: lp(5lb)

Each line represents an exercise, with optional exercise text included in a comment syntax // above each exercise.

Within an exercise, you have the exercise name (including machine, if applicable), the sets and reps, the weight, and subsequent sections for the warmup sets and progression options. If you’re more ambitious, you can code your own progressions and reps from scratch:

// Progression example
Overhead Press / 2x5 67.5lb, 1x5+ 67.5lb / warmup: 1x5 45% / progress: custom(increase: 2.5lb) {~
  if (completedReps[ns] >= reps[ns]) {
    if (completedReps[ns] >= 10) {
      weights += state.increase * 2
    } else {
      weights += state.increase
    }
  } else if (completedReps[ns] < reps[ns]) {
    weights = weights[ns] * 0.9
  }
~}

// Reps example
Reverse Fly, Leverage Machine / 3x5 / 20lb / update: custom() {~
  if (setIndex == 1) {
       reps = 4
    } else if (setIndex == 2) {
      // 3-3+ reps
       sets(2, 2, 3, 3, 1, weights[1], 0, 0, 0)
    }
~}

This is a hacker’s playground, but unlike many of the other tools I use, I would recommend this app to non-coders, too. There’s a fully-featured GUI for editing workouts if you don’t want to use code, and there are so many great quality of life features: support for different equipment (with different weights available), support for different gyms with different equipment, support for custom exercises, and the killer feature: Automatic plate math calculations. After a few leg sets, I’m approximating a 1 Intelligence Fallout Run, and therefore this feature has probably saved me hours over the last year.

This is yet another largely open source, largely solo developer project, so show it some love. I love this app so much I am trying to get the developer to support referrals so he can better understand how much I (specifically) love this app.

Request

That’s all I’ve got for now! If you read this far and wouldn’t mind thinking of me just a little bit more, could you reach out and let me know what you thought? It took me a lot of tries to write this, and to be blunt, I could use some encouragement to keep trying.

Footnotes

¹I tried to come up with a quantitative answer here, but I couldn’t. hyperfine is a great tool to test program execution speed, but my editor is open and can accept inputs is not something I can easily tie to a program ending. Claude led me to look into osascript, which is close, but VSCode boots the Electron app almost a second before it actually accepts inputs. If anyone wants to look at this, let me know!

²I am aware of obsidian.nvim. I don’t get it.

What do you mean can work?

Before we can run Jupyter, we need a virtual environment. Operating systems are rolling out PEP 668 support by default, which prohibits users from installing Python packages at the system level. (Some containers are even starting to enforce this, see here for more details). There are a lot of ways to create virtual environments - I’m using uv venv for now, but this approach is adaptable to whatever method you prefer. Once you have a virtual environment set up, you’ll also need to install molten.nvim’s Python dependencies: pynvim, jupyter_client, and (to make new kernels) ipykernel.

Second, we need a Jupyter kernel…sort of. Because we install these three packages, we get to do something cool. Usually molten.nvim prompts users to select a Jupyter kernel by hand. Boring! Instead, we can create and use the kernel on the fly based on the user’s virtual environment. Refreshingly true to its name, the kernel is indeed quite small. Each kernel is just a small text file pointing to other programs. We can view the location of our kernels with jupter kernelspec list, and, without loss of generality, see how one is constructed:

{
 "argv": [
  "/Users/zlipp/git/molten-demo/.venv/bin/python3",
  "-Xfrozen_modules=off",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "molten-demo",
 "language": "python",
 "metadata": {
  "debugger": true
 }
}

Notice that third line: The kernel is running code from the virtual environment we created for this project. That’s all there is to it! Given a virtual environment with the minimal dependencies installed, we can start executing code in asynchronous chunks, still get all the benefits of version control, and save a few bucks along the way.

About the Lua

As I mentioned, I wrote some Lua to figure out which lines to send to :MoltenEvaluateRange. I’m pretty proud of the quick-failing error handling and how the cells break on comments; that is, the comment delimiters aren’t considered to be parts of cells themselves.

One more thing I’ll note here: I started writing this script using ChatGPT, winding up with something close to useful after a few iterations. That said, you are not seeing that code now. Without exaggeration, I have rewritten every line it generated. This is the first time I have ever written Lua.

I’m skeptical of the claim that coding alongside LLMs is especially transformative; this feels exactly like copying and pasting from StackOverflow.

Random sampling

The simplest sampling method is sampling according to computed probabilities. For example, a model outputs some score, and the softmax function converts this score to 0.66. We can use a function to generate this token 66% of the time. Let’s do exactly that!

In the application below, you can choose between two prompts: - "The greatest basketball player of all time is..." - "The car is..."

I made up some possible next words for these prompts, and I made up some scores for those words. The first prompt has a high-variance output (a peaked softmax) and the second prompt a low-variance output (a flat softmax). While these initial scores are arbitrary, this app computes sampling functions and transformations in real time.

There are two ways to interact with this app: - You can change the prompt with the radio buttons - You can draw samples with the Generate the next token! button. (Note: Greedy sampling would always select the biggest number(s) here.)

Please rotate your phone to view this app

Mobile phone icons created by Freepik - Flaticon

In practice, sampling totally randomly causes generations to diverge too much to be useful. Researchers have suggested some modifications to improve this.

Temperature

We may add a parameter called temperature to modify the distribution of computed probablities. Temperature () is a scaling constant that is set to a non-negative integer. Temperatures between 0 and 1 exagerate differences in the results, while temperatures larger than 1 downplay these differences.

Let’s add a third input to the app: a slider for temperature.

Please rotate your phone to view this app

Mobile phone icons created by Freepik - Flaticon

Temperature can help shift softmax distributions around, but in practice we don’t know the shape of these distributions for each input or prmopt. People tend to set temperature by guessing and checking for some results.

Top-K sampling

What if we want to be a little more extreme than temperature, and only consider our most-likely predictions? This is called Top-K sampling, and can improve sampling.

Top-k sampling takes the top scores at each step, sets everything else to 0, and rescales those top k values them with another softmax transformation to generate a new set of probabilities. Put another way, we prevent the model from generating anything other than, for example, the 5 most likely tokens.

I’ve added a fourth input to this app: A text box for inputting a value for K. Try it out with each distribution type for 2, 3, and 4.

Please rotate your phone to view this app

Mobile phone icons created by Freepik - Flaticon

Okay, now follow my lead here. Set temperature equal to one, K equal to 3, and swap between our two prompts.

While we may be happy to only consider the top 3 predictions for the peaked (basketball) prompt, this leaves out fine predictions for the flat (car) prompt. The top 3 predictions for the basketball prompt are responsible for 99.62% of our probabilities, but the top 3 in the car prompt gives us a much smaller 63%.

This is precisely the problem. We don’t actually know the shape of these distributions and a value of K that is appropriate for one distribution may be inappropriate for another.

What if we could infer approprate values of K from the data? This motivates nucleus sampling.

Top-P (nucleus) sampling

Let’s return to the paper directly: > The key intuition of Nucleus Sampling is that the vast majority of probability mass at each time step is concentrated in the nucleus, a small subset of the vocabulary that tends to range between one and a thousand candidates. Instead of relying on a fixed top-k, or using a temperature parameter to control the shape of the distribution without sufficiently suppressing the unreliable tail, we propose sampling from the top-p portion of the probability mass, expanding and contracting the candidate pool dynamically.

One note here on scale: The authors are testing the model GPT2 in this paper, which has a fixed vocabulary of 50,257 tokens. Therefore these neighborhoods (or nuclei) of probable candidates are at most 1000/50257~1.99% of the possible results.

I find it more helpful to think of nucleus sampling as top-p sampling. Similar to top-K, let’s set unlikely tokens to 0 before we sample; but unlike a fixed top-K, let’s consider a dynamic threshold based on the sum of computed probabilities.

I’ve added a fifth and final input to the app: A slider for setting top-p. I’ve tried to visualize how top-p is computed by displaying our cumulative sum of computed probabilities as well as where p lands in this space.

Please rotate your phone to view this app

Mobile phone icons created by Freepik - Flaticon

The authors find top-p sampling to perform very well with p=0.95. They do not scale temperature in their nucleus sampling experiments, so this saves a ton of effort in manual tuning.