You open a terminal, and before you can do any actual work, you type something like:

cd ~/projects/foo/

Or if you work with WordPress:

cd ~/projects/client-site/wp-content/themes/my-custom-theme/
cd ../../plugins/my-custom-plugin/

Or Drupal:

cd ~/projects/drupal-site/web/modules/custom/my_feature_module/
cd ../../../themes/custom/my_theme/

Every. Single. Time.

It does not get easier with practice. It just gets annoying. And the worst part? You already know where everything is. Your brain has the map. The shell just refuses to use it.

That frustration is exactly why I built JustJump — a small Go CLI that lets you register the directories that matter and jump to them interactively, with two keystrokes.

The Real Problem

I work across a lot of different environments: monorepos, microservices, client projects, and DDEV containers. Deep directory trees are everywhere. Shell aliases helped me for a while, but they get stale fast — you rename a folder, and suddenly half your aliases are broken. Bookmark plugins add yet another thing to configure and maintain.

I wanted something that stayed out of my way. And yes — I know about zoxide and fzf.

I tried both. zoxide is essentially a flash bookmark manager: it learns from your history and guesses where you want to go.

fzf is a powerful fuzzy finder, but at its core it's an old-fashioned indexer and filesystem scanner — it searches what exists, not what you've decided matters. So I designed JustJump around a simple two-level model:

— Top-level project directories I register once. For example, ~/projects/myproject/.

• Local jump points — subdirectories inside a project, declared in a .justjump.yaml file. For example, backend/, frontend/.

That's it. Two levels, two commands, zero magic.

Running jj inside a registered project opens an interactive picker for that project's jump points. Running jj -G lets me switch between projects. Pick, Enter, done.

And since .justjump.yaml is just a file sitting in the project root, you can commit it to git. Every teammate who clones the repo gets the same jump points out of the box — no individual setup, no "how do you navigate this codebase" onboarding questions.

Using It Day to Day

Get It Running

Install without sudo (binary goes to ~/.local/bin):

curl -sSf https://rtech91.github.io/justjump/install.sh | bash

Or build from source if you prefer:

make build-release
make install

Then add the shell integration to your profile. Copy the right .justjumprc from misc/rc/bash/ or misc/rc/zsh/ into your home directory, then source it:

[ -f ~/.justjumprc ] && source ~/.justjumprc

Register a Project

Go to any project root and run:

cd ~/projects/myproject
jj add -G
# -> Global jump root added: myproject -> ~/projects/myproject

Define Your Jump Points

Drop a .justjump.yaml in the project root:

jumppoints:
  - backend/
  - frontend/
  - infra/terraform/

You can also cd into any subdirectory and run jj add (no -G) to register that path directly.

Jump

Inside a registered project:

jj
# -> interactive picker with local jump points

From anywhere, to switch projects:

jj -G
# -> interactive picker with global roots

Keep Things Clean

Remove what's no longer relevant:

jj remove        # removes current dir's local jump point
jj remove -G     # removes the current project root registration

DDEV Integration

If you use DDEV, you know the pain of container paths. /var/www/html/web/modules/custom/mymodule is not something you want to type repeatedly.

Since container paths differ from host paths, registration has to happen inside the container. Here's my setup in .ddev/config.yaml:

webimage_extra_packages: [golang]
hooks:
  post-start:
    - exec: curl -sSf https://rtech91.github.io/justjump/install.sh | bash
    - exec: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

After ddev start or ddev restart:

ddev ssh
cd /var/www/html
jj add -G

Then add .justjump.yaml at the container project root:

jumppoints:
  - web/modules/custom/
  - web/themes/custom/
  - config/sync/

From that point on, jj inside the container gives you instant navigation. If you use Zsh inside DDEV, also append to .zshrc:

hooks:
  post-start:
    - exec: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc

A Few Design Decisions I'm Happy With

No database, no daemon. Everything lives in plain files under ~/.config/justjump/. Nothing runs in the background. You can audit, backup, or delete the whole thing with standard shell tools.

No silent stale paths. JustJump skips missing entries and warns you. jj verify makes the health check explicit when you want it.

Consistent mnemonic flags. The --global / -G flag works the same way across add, remove, verify, and jumping. Learn it once, use it everywhere.

Wrapping Up

JustJump is not trying to be clever. It is just removing the friction between knowing where you want to go and actually getting there.

Register a project root once. Define meaningful local jump points. Type jj, pick, Enter. That's the whole thing — and it works the same way on your laptop and inside a DDEV container.

The source is on GitHub if you want to try it or poke around the code. Happy to hear how others are using it or what you'd do differently.