Just Command Runner: Streamline Project Commands in 2025

Just Command Runner: Simplify Your Development Workflow with This Powerful Rust CLI Tool

In the world of software development, managing project-specific commands can quickly become chaotic. From complex build scripts to repetitive testing commands, developers often waste valuable time recalling or rewriting these commands. Enter just command runner – a lightweight, flexible tool written in Rust that serves as an excellent alternative to traditional makefiles. With over 27,000 stars on GitHub, just has established itself as a go-to rust command runner for developers seeking to organize their project commands efficiently.

What is Just Command Runner?

At its core, just is a command-line tool designed to store and run project-specific commands, which it refers to as "recipes." These recipes are defined in a justfile, using a syntax inspired by make but with significant improvements that make it more accessible and less error-prone. Unlike make, which was primarily designed as a build system, just focuses solely on being a project command organizer, eliminating much of the complexity associated with traditional build tools.

The project, created by Casey Rodarmor in 2016, has steadily gained popularity due to its cross-platform support (Linux, macOS, Windows, and other Unix-like systems) and its commitment to simplicity and user experience. As a rust command runner, just benefits from Rust's performance, safety, and reliability, making it a robust choice for developers across different ecosystems.

Just vs Make: Why Choose Just?

While make has been the de facto standard for decades, it comes with several idiosyncrasies that can frustrate developers who just want to run commands efficiently. Here's how just vs make stacks up:

1. Simplified Syntax: Just eliminates the need for .PHONY targets, a common source of confusion in makefiles. Every recipe in just is treated as a command to run, not a file to build.

2. Better Error Handling: Just provides specific, informative error messages with context, making debugging much easier than with make's often cryptic error output.

3. Native Cross-Platform Support: Unlike make, which can be cumbersome on Windows, just works seamlessly across all major operating systems without additional dependencies.

4. Command-Line Arguments: Just recipes can accept parameters directly, a feature that requires workarounds in make.

5. Environment File Support: Just automatically loads .env files, simplifying environment variable management for your projects.

6. Modern Features: Just includes quality-of-life improvements like command-line completion, recipe listing, and the ability to invoke commands from any subdirectory.

For most command-running scenarios, just provides a more intuitive and developer-friendly experience than traditional makefiles.

Getting Started with Just: Installation and Basic Usage

Installing just cli tool is straightforward across all platforms. Depending on your operating system, you can use one of the following methods:

## Using Cargo (Rust's package manager)
cargo install just

## On macOS using Homebrew
brew install just

## On Ubuntu/Debian
apt install just

## On Fedora
dnf install just

## On Windows using Chocolatey
choco install just

Once installed, verify the installation with:

just --version

To start using just in your project, create a file named justfile (or Justfile, .justfile for hidden files) in your project root.

Justfile Tutorial: Creating Your First Recipes

A justfile uses a simple syntax for defining recipes. Let's start with a basic example:

## This is a comment
hello:
  echo "Hello, World!"

test:
  @echo "Running tests..."
  cargo test

build:
  @echo "Building project..."
  cargo build --release

In this example:

• Lines starting with # are comments
• Recipe names (like hello, test, and build) are followed by a colon
• Indented lines below each recipe are the commands to execute
• Lines starting with @ won't be printed before execution

To run a recipe, simply use:

just hello
just test
just build

If you run just without any arguments, it will execute the first recipe in your justfile.

Justfile Syntax: Beyond the Basics

Justfile syntax supports several advanced features that make it a powerful project command organizer:

Recipe Dependencies

You can define dependencies between recipes:

test: build
  @echo "Running tests..."
  cargo test

build:
  @echo "Building project..."
  cargo build

Now running just test will first execute the build recipe, then the test recipe.

Recipe Parameters

Just recipes can accept parameters, making them more flexible:

greet name:
  echo "Hello, {{name}}!"

## With default values
deploy environment="production":
  @echo "Deploying to {{environment}} environment..."
  ./deploy.sh {{environment}}

Run these recipes with:

just greet "John Doe"
just deploy staging

Variables and Environment Files

Just supports variables and can load environment variables from .env files:

set dotenv-load  # Load variables from .env file

database_url := env("DATABASE_URL")

migrate:
  @echo "Migrating database: {{database_url}}"
  sqlx migrate run

Conditional Expressions

You can use conditional logic in your justfiles:

test os="linux":
  @echo "Running tests on {{os}}..."
  {{ if os == "windows" { "cargo test -- --test-threads=1" } else { "cargo test" } }}

Advanced Just Features

As you become more familiar with just rust usage, you'll discover several advanced features that can further streamline your workflow:

Shebang Recipes

Just supports shebang recipes for writing commands in other languages:

python-hello:
  #!/usr/bin/env python3
  print("Hello from Python!")

node-script:
  #!/usr/bin/env node
  console.log("Hello from Node.js!");

Private Recipes

Prefix recipe names with an underscore to hide them from just --list:

_test-setup:
  @echo "Setting up test environment..."
  # Setup commands here

test: _test-setup
  @echo "Running tests..."
  cargo test

Modules

Organize complex justfiles into modules for better maintainability:

mod build  # Looks for build.just or build/mod.just
mod test   # Looks for test.just or test/mod.just

## Run recipes from modules
ci: build::all test::all

Just Command Examples: Practical Use Cases

Let's explore some practical just command examples that demonstrate the power and flexibility of this tool:

Development Server with Environment Variables

set dotenv-load

serve port=3000:
  @echo "Starting server on port {{port}}..."
  PORT={{port}} DATABASE_URL={{database_url}} node src/server.js

Multi-Step Deployment Process

deploy environment="production":
  @echo "Starting {{environment}} deployment..."
  just build
  just test
  just deploy-database {{environment}}
  just deploy-app {{environment}}
  @echo "{{environment}} deployment complete!"

deploy-database environment:
  @echo "Deploying database migrations to {{environment}}..."
  # Database migration commands

deploy-app environment:
  @echo "Deploying application code to {{environment}}..."
  # Application deployment commands

Project Initialization Script

init:
  @echo "Initializing new project..."
  git init
  cargo init
  touch .env
  echo "DATABASE_URL=sqlite://database.db" >> .env
  just setup-git-hooks

setup-git-hooks:
  @echo "Setting up git hooks..."
  mkdir -p .git/hooks
  echo "#!/bin/sh\njust lint" > .git/hooks/pre-commit
  chmod +x .git/hooks/pre-commit

When to Use Just: Ideal Scenarios

Just command runner shines in several scenarios:

1. Project-specific Command Organization: Keep all your project's unique commands in one place for easy access and documentation.

2. Onboarding New Team Members: A well-documented justfile helps new team members quickly learn how to build, test, and deploy your project.

3. Cross-Platform Development Teams: Just ensures consistent command execution across different operating systems.

4. Complex Build and Deployment Pipelines: Break down complicated processes into manageable, reusable recipes.

5. Open Source Projects: Provide users with an intuitive way to interact with your project without memorizing complex commands.

Conclusion: Simplify Your Development Workflow with Just

In the fast-paced world of software development, every second counts. Just command runner helps you reclaim valuable time by organizing your project's commands in an intuitive, maintainable way. Whether you're working on a small personal project or a large enterprise application, just's simplicity, flexibility, and performance make it an excellent addition to your development toolkit.

By leveraging justfile recipes, you can create a consistent interface for interacting with your projects, reduce onboarding time for new team members, and eliminate the frustration of recalling complex command sequences. As a modern alternative to make, just addresses many of the pain points developers face with traditional build tools while adding powerful new features tailored to today's development workflows.

If you haven't already, give just cli tool a try on your next project. With its gentle learning curve, extensive documentation, and active community, you'll wonder how you ever managed without it.

Additional Resources

• Official Documentation: https://just.systems/man/en/
• GitHub Repository: https://github.com/casey/just
• Justfile Examples: https://github.com/casey/just/tree/master/examples
• Discord Community: https://discord.gg/ezYScXR

Start simplifying your development workflow today with just – the powerful, rust-based command runner that's changing how developers organize their project commands.