u/Fabulous-Lobster9456

▲ 0 r/kimi

https://reddit.com/link/1t5w6lk/video/kexb2fyt9mzg1/player

I’ve been experimenting with OMK’s project ontology workflow, and it’s actually more straightforward than I expected.

The basic flow is just prompting it with something like:

>

From there, OMK scans the current workspace context, picks out the important components as nodes, and maps out dependencies as edges. So instead of manually building some graph from scratch, you basically let it infer the project structure first.

The output gets saved as a .json ontology map. Raw JSON graphs are not exactly fun to inspect, so the useful part is that OMK has a built-in skill that converts that ontology JSON into an interactive .html visualization.

That HTML view makes it much easier to sanity-check whether the model actually understood your architecture instead of just vaguely summarizing files.

To be clear, I’m not claiming this is a perfect semantic knowledge graph implementation. Dynamic node updates, complex relationships, and schema correction still have rough edges. You’ll probably still hit cases where the graph needs manual cleanup.

But pragmatically, it does seem useful for reducing hallucinations.

Instead of letting the Kimi model rely only on a long, messy, decaying context window, the ontology JSON gives it a more stable reference point. That seems to help prevent the usual “invented variable / forgotten architecture rule / fake dependency” problem.

Has anyone else tried rendering their workspace into the HTML ontology view yet?

I’m especially curious how well the JSON-to-HTML skill holds up on larger enterprise-scale codebases.

https://github.com/dmae97/oh-my-kimi

reddit.com
u/Fabulous-Lobster9456 — 8 days ago
▲ 2 r/kimi+1 crossposts

https://reddit.com/link/1t2say3/video/w9hvcjfgmyyg1/player

opencode 1.14.3 vs omk 1.0.0 ( not release yet)

Prompt:

You are Kimi Code running as an autonomous coding agent.

Task:

Create a complete browser-playable first-person 3D game project from scratch using Three.js, Vite, and TypeScript.

Game title:

"Neon Courier: Ray District"

Game concept:

A cyberpunk first-person survival shooter set inside a neon industrial district. The player explores a small procedural arena, fights hostile drones, collects energy cores, and survives waves. The game should demonstrate real-time 3D rendering, first-person controls, ray-tracing-inspired lighting/reflections, and a complete playable game loop.

Important technical direction:

This is a one-prompt challenge. Build the most complete working project possible.

Use Three.js + Vite + TypeScript.

Do not create a single HTML file.

Do not rely on external image, audio, font, model, or network assets.

Use procedural geometry, generated materials, shader effects, and simple generated meshes only.

Ray tracing / advanced rendering requirement:

Implement a ray-tracing-inspired visual pipeline as far as possible within a browser project.

Preferred approach:

- Use a hybrid Three.js renderer.

- Add reflective neon materials, emissive surfaces, bloom-like glow, dynamic lights, and shadowing.

- Implement at least one custom shader or fullscreen pass that demonstrates ray-tracing-style behavior, such as:

- ray-marched neon reflections

- screen-space reflections

- simple path-traced accumulation for a small reflective scene

- ray-cast mirror/reflection approximation

- ray-marched signed-distance-field objects

- If true browser WebGPU/path tracing is not feasible in the current environment, implement a clear fallback using WebGL-compatible shader effects and document the limitation in RUN_REPORT.md.

- Do not falsely claim full hardware ray tracing if it is not implemented.

- The final visual result should clearly show reflective neon lighting and ray-tracing-inspired effects.

Hard requirements:

  1. Create a complete project, not a single HTML file.

  2. Use Three.js, Vite, and TypeScript.

  3. The project must run with:

    - npm install

    - npm run dev

    - npm run build

  4. Include a polished start screen, gameplay scene, pause/game-over flow, and restart.

  5. Include a README.md explaining how to run the game and what was implemented.

  6. Include a RUN_REPORT.md describing:

    - what was built

    - files created

    - commands run

    - whether build/typecheck passed

    - rendering approach

    - ray tracing / reflection technique used

    - agents/roles used

    - MCP tools used, if any

    - skills or reusable workflows used, if any

    - parallel workstreams attempted

    - known limitations

  7. After implementation, run install/build/typecheck commands if possible. If errors occur, fix them before finishing.

  8. Prefer simple working code over complex broken code.

Gameplay requirements:

- First-person camera with mouse look using Pointer Lock.

- Player movement with WASD and arrow keys.

- Sprint with Shift.

- Jump or hover-dash with Space.

- Player shoots energy projectiles with mouse click.

- Enemy drones spawn in waves and chase or shoot at the player.

- Player has health and can take damage.

- Enemies can be destroyed.

- Energy cores spawn around the map and increase score when collected.

- Include at least 3 waves with increasing difficulty.

- Include HUD with:

- health

- score

- wave number

- timer

- enemies remaining

- rendering mode / quality indicator

- Include game-over state with final score and restart instruction.

- Include basic collision against arena walls and obstacles.

- Include at least one weapon effect, one enemy death effect, and one pickup effect.

3D world requirements:

- Procedural cyberpunk arena.

- Neon grid floor.

- Reflective walls or panels.

- Emissive signs or light strips.

- Obstacles / cover objects.

- At least one visually distinct central structure.

- No external models or textures.

- Generate geometry procedurally using Three.js primitives.

- Use generated canvas textures only if needed.

Rendering / visual polish requirements:

- Dark cyberpunk style.

- Neon emissive materials.

- Reflective surfaces.

- Dynamic lights.

- Shadows if feasible.

- Bloom-like glow or postprocessing glow approximation.

- Particle effects for shots, hits, pickups, and enemy death.

- Screen shake or camera recoil on shooting/hit.

- Hit flash or damage vignette.

- Quality toggle or graceful fallback for lower-end machines.

- Make it look intentionally designed, not like a default Three.js demo.

Technical structure requirements:

Use a clean modular structure similar to:

src/

main.ts

game/

App.ts

config.ts

constants.ts

types.ts

core/

Renderer.ts

Input.ts

Audio.ts

Clock.ts

scenes/

MenuScene.ts

GameScene.ts

GameOverScene.ts

world/

Arena.ts

Lighting.ts

Materials.ts

ProceduralTextures.ts

entities/

Player.ts

EnemyDrone.ts

Projectile.ts

EnergyCore.ts

systems/

WaveSystem.ts

CombatSystem.ts

CollisionSystem.ts

HudSystem.ts

ParticleSystem.ts

RenderEffectsSystem.ts

shaders/

raymarchReflection.ts

glowPass.ts

utils/

math.ts

random.ts

You may adjust the structure if needed, but keep the project modular and maintainable.

Agent / orchestration requirements:

- Use all available agents, subagents, roles, or specialist workers provided by the current coding environment or harness.

- Decompose the task into parallelizable workstreams where possible:

- project setup

- Three.js renderer and game loop

- FPS controls and collision

- enemy/wave/combat systems

- procedural arena and materials

- ray-tracing-inspired shader/reflection effects

- HUD/menu/game-over UI

- particles and visual polish

- build verification

- README and RUN_REPORT documentation

- Use parallel processing or concurrent agent execution if the environment supports it.

- Use all available MCP tools, skill systems, tool integrations, or reusable coding skills when they are relevant to the task.

- Do not fabricate tool usage. If an agent, MCP tool, skill, or parallel execution feature is unavailable, continue with the best available method and document the limitation in RUN_REPORT.md.

- Before finishing, run a final reviewer/verifier pass to check:

- whether the project builds

- whether the game is playable

- whether all required files exist

- whether the implementation matches the prompt

- whether the rendering technique is honestly documented

- whether README.md and RUN_REPORT.md accurately describe the result

Acceptance criteria:

The final result should be judged by these criteria:

  1. npm install works.

  2. npm run dev starts the game.

  3. npm run build succeeds.

  4. The game is actually playable as a first-person game.

  5. Mouse look / pointer lock works.

  6. WASD movement works.

  7. Shooting works.

  8. Enemies spawn, chase or attack, and can be destroyed.

  9. Waves, score, health, pickups, timer, and restart work.

  10. The code is modular and readable.

  11. The game has start, gameplay, and game-over flow.

  12. The world has cyberpunk/neon visual identity.

  13. Ray-tracing-inspired rendering or reflection/shader effects are present.

  14. The implementation honestly documents whether it is true path tracing, ray marching, screen-space reflection, or approximation.

  15. README.md and RUN_REPORT.md exist.

Important:

- Do not stop after planning.

- Do not only describe the implementation.

- Actually create the files.

- Do not output only code snippets.

- Do not output only HTML.

- Do not use external assets.

- Prefer a working playable game over an overambitious broken renderer.

- If a requirement conflicts with making the game run, prioritize a working playable game and document the compromise in RUN_REPORT.md.

- If full ray tracing is not feasible, implement the best ray-tracing-inspired approximation and document it clearly.

reddit.com
u/Fabulous-Lobster9456 — 12 days ago
▲ 10 r/kimi+1 crossposts

https://reddit.com/link/1t1rprd/video/wp0wikzqjqyg1/player

https://preview.redd.it/woyzln70kqyg1.png?width=813&format=png&auto=webp&s=f321369b036adf15e603cef62b7e2216d1d3099d

Just dropped v0.4.0-alpha of [oh-my-kimichan]

https://github.com/dmae97/oh-my-kimichan

a Kimi-native CLI harness that turns your Kimi Code CLI into a multi-agent coding team.

The vibe check:

I told it "make me a COS-style minimal landing page" in basically one prompt and it spat out a clean, responsive site with the whole orchestrator → worker → reviewer pipeline running behind the scenes. Took like 10-20 mins tops.

*tl;dr: one prompt -> COS landing page. 10-20 min. Kimi-native multi-agent CLI behind it. Thoughts?*

reddit.com
u/Fabulous-Lobster9456 — 13 days ago
▲ 2 r/kimi

https://preview.redd.it/tbuf8tyspjyg1.png?width=1015&format=png&auto=webp&s=16934400400ce72e276a01a8a75c2fef11fa17ac

Hey r/kimi,

A few months back I shared [oh-my-kimichan](https://github.com/dmae97/oh-my-kimichan), a harness that turns Kimi CLI into a worktree-based coding

team. Today I shipped v0.30. with a ton of stuff I actually use every day, so here’s what's new.

---

### 🚀 What’s New in v0.3.0

| Feature | What it does |

|---------|--------------|

| `omk parallel <goal>` | Spawns a coordinator → worker fan-out → reviewer DAG in parallel. Real-time ETA + live UI refresh every 1.5s. |

| `omk hud` | Terminal dashboard with System / Kimi Usage gauges, Project Status, latest run, TODO & changed-files sidebar. |

| Bare `omk` TTY menu| Run `omk` with no args and get an interactive HUD + `@inquirer/prompts` menu. Zero-config onboarding. |

| `--run-id` resume | Long agent runs survive restarts. Resume from `.omk/runs/` persisted state. |

| SendDMail checkpoints + Snippets | Save rollback checkpoints before risky refactors. Reuse code blocks across sessions via `.omk/snippets/`

. |

| Local Graph Memory*| Project/session memory stored in `.omk/memory/graph-state.json` as an ontology graph. Mindmap + GraphQL-lite recall, n

o Neo4j required. |

| Role-aware Ensemble | Coder / planner / architect / reviewer / QA / explorer nodes with weighted candidates + quorum aggregation. |

| Built-in LSP | `omk lsp typescript` bundles the TypeScript language server for agent/editor shared intelligence. |

| 16GB-friendly runtime | Auto-detects RAM and switches to a lite profile. Runs smooth on laptops and WSL. |

| Quality gates wired to CI | `npm run check / test / lint / build` enforced in CI. |

---

### 🖼️ New screenshots

https://preview.redd.it/94xh5gm5yiyg1.png?width=1253&format=png&auto=webp&s=0e1249451fe689d4bdfd27ed0f61ae34025d6d02

https://preview.redd.it/kevdrx89yiyg1.png?width=1341&format=png&auto=webp&s=1cacc4c9dda6afb8017805385079f00e8a72cd10

---

### Quick start

```bash

npm install -g oh-my-kimichan

omk init

omk doctor

omk chat

# or just run `omk` for the TTY menu

Everything is open source (MIT) and Kimi K2.6 native — Okabe context management, D-Mail checkpoints, and subagent orchestration included.

Would love feedback, bug reports, or PRs. If you’re using Kimi CLI for serious work, what’s the one feature you wish existed?

GitHub: https://github.com/dmae97/oh-my-kimichan

reddit.com
u/Fabulous-Lobster9456 — 14 days ago
▲ 139 r/kimi+3 crossposts

GitHub: https://github.com/dmae97/oh-my-kimichan

​What makes this different?

​This isn't just a simple wrapper.

It’s a harness designed for high-quality

agentic workflows:

​Worktree-based Parallel Coding: It manages a "coding team" using git worktrees. Parallel development without the branch mess.

​Quality Gates & HUD: Includes a real-time HUD to track workers, tests, and risks. It won't let the agent finish until it passes your quality gates.

​Design-First approach: Deep integration with Google's DESIGN.md. It uses design docs as the source of truth for UI/Logic generation.

​Cross-compatibility: Fully supports AGENTS.md, GEMINI.md, and CLAUDE.md specs. You can drop your existing agent definitions and they just work.

​Kimi K2.6 Optimized: Tailored specifically to squeeze the best performance out of Moonshot’s latest models.

u/Fabulous-Lobster9456 — 15 days ago