SkillFoxx

EVEngine skill

The EveScript skill and built-in MCP of the EVEngine game engine: an agent writes .nut scripts and checks the API catalog

  • 65 ★ on the repository
  • Last commit
Skill

Extended access

Why this level

  • The engine runs game scripts and opens a local MCP port in debug mode
  • The SDK is downloaded as a prebuilt binary archive with no build from source
All reasons and checks

evengine/evengineAuthor:EVEngine

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/evengine

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The engine runs game scripts and opens a local MCP port in debug mode
  • The SDK is downloaded as a prebuilt binary archive with no build from source

This is third-party code. Review the repository files before installing.

What it does

EVEngine is an open-source game engine in C++20 and Vulkan with EveScript scripting (Squirrel-compatible). It is built for quick work by a developer together with an AI agent: a game starts with `config.nut` and `main.nut` in an ordinary folder and runs with a prebuilt SDK. For the agent the engine provides the `evescript` skill and MCP tools. The `evescript` skill lives in `.cursor/skills/evescript/SKILL.md` and in an unzipped SDK. It tells the agent not to invent Unity C#, Godot GDScript, Lua or JavaScript APIs: EVEngine games have a single language, `.nut`. The skill covers the lifecycle (`eve_init`, `eve_update(dt)`, `eve_render`), `persist` state, module setup in `config.nut`, imports with `import { x } from "./scripts/foo.nut"` and gradual typing. The agent gets API reference three ways: MCP tools `eve_api_search` and `eve_api_get` when running `bin/eve run --debug --mcp-port=7529`, the `share/eve/ai/eve-api.json` file in the SDK, or the `generate_binding_contracts.py` script in the source tree. The engine itself covers 2D, HD-2D, 3D graphics, physics, animation, UI, audio, hot reload and networking.

Who it is for. Game developers who build prototypes and small projects in scripts together with Claude Code, Codex or Cursor.

Good fit when

  • The agent must write gameplay in `.nut` and not substitute APIs of other engines
  • Calls to `eve.*` must be checked against the catalog through `eve_api_search` and `eve_api_get`
  • A project is built in quick iterations with hot reload and editing inside the running game
  • A game mixes 2D assets with a 3D scene, such as HD-2D tilemaps

Not a fit when

  • The game is already built in Unity, Godot or Unreal: the skill knows EveScript only
  • A ready visual editor without scripts is needed
  • The platform is not among SDK builds: it must be built from source

Example request

Write player movement along the X axis at 180 units per second in EveScript and verify call names with `eve_api_search`

Limitations

The skill and MCP work only with EVEngine and the EveScript language and are useless for other engines. The license is listed as NOASSERTION, so read it in the repository before commercial use. The engine is complex: building from source needs platform tooling (Vulkan SDK, MSVC, Xcode, Ninja and submodules), so start with a prebuilt SDK. Some documentation and agent notes are in Chinese. The `eve_eval` path is not an official way to write gameplay logic, as `AGENTS.md` states. Graphics tests do not run on some CI lanes, and on platforms such as Windows ARM64 the engine is built without them.

How to disable. Delete the `.cursor/skills/evescript/` folder or the whole SDK. The MCP server runs only while `bin/eve run --debug --mcp-port=...` is running.

FAQ

How do I connect the EVEngine skill to an agent?

Unzip the SDK and take `.cursor/skills/evescript/SKILL.md`, and for Claude Code copy it to `.claude/skills/evescript/`. The repository `AGENTS.md` tells game-script agents to read this skill.

What language are games written in?

In EveScript (`.nut` files), a Squirrel extension with compile-time checks. There is no second runtime language, so Unity, Godot or Lua APIs must not be substituted.

How does the agent verify API names?

Through the MCP tools `eve_api_search` and `eve_api_get`, started with `bin/eve run --debug --mcp-port=7529`, or from the `share/eve/ai/eve-api.json` catalog in the SDK.

What is persist in EveScript?

The `persist name = value` keyword keeps state that survives script hot reload. C# fields and `static` do not work for that.

Do I need to build the engine from source?

No, a prebuilt SDK archive such as `eve-sdk-<platform>-<version>.zip` is enough to start. Building is for engine work and platforms without an SDK.

Discussion

No questions or reviews yet.

Skills

About 76 Unreal Engine 5.8 skills: C++, Blueprints, GAS, animation, materials, MetaHuman and Ultra Dynamic packs

SkillMinimal access102
Official

The summer-engine package links an agent to the Summer game engine: MCP server, game-dev skills and a CLI to build and publish.

MCP serverBroad access103

A set of game-dev skills for AI agents with a router that picks the right ones for the engine and task

SkillMinimal access8.7K

A Python CLI and MCP server that lets an agent spawn actors, edit Blueprints and run PIE sessions in Unreal Engine 5

CLIBroad access216

Unreal Engine Skills

Unreal Engine Skills for AI Agents

31 skills for Unreal Engine 5.8 C++: GAS, networking, Niagara, World Partition, Mass Entity and hints on deprecated APIs

SkillMinimal access449
Editors’ pick

Official Unity skill set for agents: editor control, builds, 2D and 3D, UI, URP, audio, multiplayer and monetization

SkillExtended access1.2K

README in short

The English README covers the engine goals, key features, built-in systems, documentation and builds for various platforms, including native Intel Mac and ARM64 builds. Separate agent notes live in `AGENTS.md` and the skill.

README badge

Original SKILL.md

---
name: evescript
description: Write EveScript (.nut) for EVEngine. Use when editing game scripts, calling eve.* APIs, or driving the engine from an AI agent.
---

# EveScript / EVEngine for agents

Do not invent Unity C#, Godot GDScript, Lua, or JavaScript APIs. EVEngine games are `.nut` (EveScript = Squirrel + compile-time extensions). There is no second runtime language.

Lookup before writing (do not guess Unity/Godot names):

1. Live MCP: `eve_api_search` / `eve_api_get` on `bin/eve run --debug --mcp-port=7529 …`
2. **SDK zip** (no engine source): `share/eve/ai/eve-api.json` (same catalog as this `eve` binary)
3. Engine git tree only: `python3 scripts/generate_binding_contracts.py --json-output eve-api.json`

Cursor skill copy in an unzipped SDK: `.cursor/skills/evescript/SKILL.md`. Human tutorial: `docs/usr/EVESCRIPT.md` in the source tree / online docs. Longer engine-maintainer note: `docs/dev/AI知识补偿.md`.

## Language (differences from JS/C#)

- Lifecycle: `eve_init`, `eve_update(dt)`, `eve_render`, optional `eve_reload` / `eve_asset_reload`.
- Hot-reload-safe state: `persist name = init` (not C# fields, not `static`).
- Slot assign: `eve_update <- function(dt) { ... }` or `eve_update = function(dt) { ... }`.
- Modules: `config.nut` lists `modules` / `optionalModules` by **root slot** (`gfx`, not CMake `graphics`).
- Do not use `"Graphics" in eve` — `in` does not trigger lazy binding. Use `eve.moduleList` / `has_module("gfx")` / `ensure_module("audio")`.
- `switch` is a Squirrel keyword. UI factory: `ui["switch"]`.
- Import: `import { x } from "./scripts/foo.nut"` then `export function`.
- Types are gradual (`float`, `int`, `->`). They erase at runtime; they help the compiler/LSP.

Minimal game:

```squirrel
persist playerX: float = 100.0

eve_init <- function() {
    gfx.setBackgroundColor(0.08, 0.10, 0.16, 1.0)
}

eve_update <- function(dt: float) {
    playerX += 180.0 * dt
}

eve_render <- function() {
    gfx.clear()
    gfx.drawSolidRect(playerX, 220.0, 48.0, 48.0, 0.3, 0.75, 1.0, 1.0)
}

Report a problem