New Modular Project logo

New Modular Project

Organization
modular
new-modular-project

Creates a new Mojo or MAX project. Use when wanting to start a new Mojo or MAX project, initializing the `pixi` or `uv` environment to use Mojo or MAX, or when the user wants to begin a new Mojo or MAX project from scratch.

Overview

Publishermodular
Repositoryskills
Skill namenew-modular-project
Stars
204
Forks
21
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by modular on GitHub. Read the source before you install it.

Installation

Install the New Modular Project AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/modular/skills/tree/main/new-modular-project
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/modular/skills.git /tmp/skills
mkdir -p .claude/skills
cp -r /tmp/skills/new-modular-project .claude/skills/new-modular-project
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable New Modular Project in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads New Modular Project on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so New Modular Project is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

When the user wants to create a new project, first infer as many options as possible from the user's request (for example, "new Mojo project" means type=Mojo, "called foo" means name=foo). Then use a structured multiple-choice prompt (not plain text) to gather only the remaining unspecified options in a single interaction. Do NOT ask about options the user has already provided or implied. The options to determine are:

  • Project name: ask if the user hasn't specified one.
  • Type of project: Mojo or MAX (infer from context if the user said "Mojo project" or "MAX project").
  • Environment manager: pixi (recommended) or uv.
  • uv project type (only when the environment manager is uv): full uv project (uv init + uv add, recommended) or quick uv environment (uv venv + uv pip install, lighter weight).
  • Channel: nightly or stable. Default to nightly for MAX projects and stable for Mojo projects, and ask only if the user hasn't implied one.

Then follow the appropriate section below (pixi or uv) to initialize the project and choose max or mojo as appropriate. Don't pin a version: each channel already resolves to the right one.

MAX and Mojo ship together but number their releases differently, so their version strings don't look alike. On the stable channel, max is 26.5 while mojo is 1.0.0; on nightly they're 26.6.0.dev* and 1.1.0.dev*. That's expected, not a mismatch.

[!NOTE] Mojo and MAX projects use pixi. The magic CLI is retired; its replacement is the modular CLI. Don't use or suggest magic.


System prerequisites

Mojo requires a C linker for compilation. Install one if not already present:

OSCommand
Ubuntu/Debiansudo apt install gcc
Fedora/RHELsudo dnf install gcc
macOSxcode-select --install
WindowsInstall WSL2 first (see Windows users), then install gcc

Windows users: Mojo doesn't run natively on Windows. Install WSL2 (wsl --install in PowerShell), then follow the Linux instructions inside your WSL environment.


Pixi (recommended)

Pixi manages Python, Mojo, and other dependencies in a reproducible manner inside a controlled environment.

First, determine whether pixi is installed. If it isn't available at the command line, install it using the latest instructions at https://pixi.prefix.dev/latest/#installation.

After installing pixi, you may need to add it to the local shell environment.

Nightly

bash
# New project
pixi init [PROJECT] \
  -c https://conda.modular.com/max-nightly/ -c conda-forge \
  && cd [PROJECT]
pixi add [max / mojo]
pixi shell

# Existing project - add to pixi.toml channels first:
# [workspace]
# channels = ["https://conda.modular.com/max-nightly/", "conda-forge"]
pixi add [max / mojo]

Stable

bash
# New project
pixi init [PROJECT] \
  -c https://conda.modular.com/max/ -c conda-forge \
  && cd [PROJECT]
pixi add [max / mojo]
pixi shell

# Existing project
pixi add [max / mojo]

Python-using projects

If your project uses Python libraries with Mojo:

bash
pixi add python
pixi add requests           # conda-forge packages
pixi add --pypi some-pkg    # PyPI-only packages

uv

uv is a fast and very popular package manager, familiar to developers coming from a Python background. It also works well with Mojo projects.

Nightly (project)

bash
uv init [PROJECT] && cd [PROJECT]
uv add [max / mojo] \
  --index https://whl.modular.com/nightly/simple/ \
  --prerelease allow

Stable (project)

bash
uv init [PROJECT] && cd [PROJECT]
uv add "max[all]"

This resolves from PyPI. The all extra pulls in mojo and the rest of the MAX stack, so the MAX and Mojo versions always match.

Nightly (quick environment)

bash
mkdir [PROJECT] && cd [PROJECT]
uv venv
uv pip install [max / mojo] \
  --index https://whl.modular.com/nightly/simple/ \
  --prerelease allow

Stable (quick environment)

bash
mkdir [PROJECT] && cd [PROJECT]
uv venv
uv pip install "max[all]"

When using uv, you can use max or mojo directly by working within the project environment:

bash
 source .venv/bin/activate

pip

Standard Python package manager.

Nightly

bash
python3 -m venv .venv && source .venv/bin/activate
pip install --pre [max / mojo] \
  --extra-index-url https://whl.modular.com/nightly/simple/

Use --extra-index-url, not --index-url. The latter replaces PyPI, and the nightly index doesn't carry third-party dependencies like numpy, so pip backtracks through every max version instead of reporting a clear error.

Stable

bash
python3 -m venv .venv && source .venv/bin/activate
pip install "max[all]"

As with uv, the all extra installs mojo as well, so the MAX and Mojo versions always match.


Conda

For conda and mamba users.

Nightly

bash
conda install -c conda-forge \
  -c https://conda.modular.com/max-nightly/ [max / mojo]

Stable

bash
conda install -c conda-forge \
  -c https://conda.modular.com/max/ [max / mojo]

Version alignment with MAX

If using MAX with custom Mojo kernels, both must come from the same channel. Don't compare their version numbers: MAX and Mojo number releases differently, so a matching pair looks mismatched (stable is max 26.5 with mojo 1.0.0).

bash
# Check that both came from the same channel
pixi list | grep -E "^(max|mojo)\b"

Or, instead install max[all] (with pip/uv) or max-all (with conda/pixi):

bash
uv add "max[all]"
bash
pixi add max-all

Installing max with "all" optional dependencies instead of installing max and mojo separately will ensure that the max and mojo versions always match. Mixing versions between the two causes kernel compilation failures.


References

Frequently asked questions

What does the New Modular Project AI skill do?

Creates a new Mojo or MAX project. Use when wanting to start a new Mojo or MAX project, initializing the `pixi` or `uv` environment to use Mojo or MAX, or when the user wants to begin a new Mojo or MAX project from scratch.

Why use New Modular Project on TypingMind?

Because you install it once and use it with any model. New Modular Project is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install New Modular Project in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/modular/skills/tree/main/new-modular-project. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use New Modular Project?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with New Modular Project?

As many as you like. As long as a model supports skills, you can use New Modular Project with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the New Modular Project AI skill free?

It is published on GitHub by modular. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇