EN JP CN

Your text editor
for code

Native speed

Local-first AI

Multi-pane

Scriptable

Download for Mac Pricing

v0.1.0 (closed alpha) – Releases – Issue tracker

_• tray_timer.py .hackerman

 1   
 2    How does rumps work in python? Give a small example
 3   
 4    > rumps (Ridiculously Uncomplicated Mac os x Python Statusbar) creates macOS menu bar apps.
 5    >
 6    > Here's a small example:
 7    >
 8    > import rumps
 9    >
10    > class MyApp(rumps.App):
11    >     def __init__(self):
12    >         super().__init__("MyApp", icon="icon.png")
13    >         self.menu = ["Preferences", "About", rumps.separator, "Quit"]
14    >
15    >     @rumps.clicked("Preferences")
16    >     def prefs(self, _):
17    >         rumps.alert("Preferences clicked!")
18    >
19    >     @rumps.clicked("About")
20    >     def about(self, _):
21    >         rumps.alert("This is my app!")
22    >
23    >     @rumps.clicked("Quit")
24    >     def quit_app(self, _):
25    >         rumps.quit_application()
26    >
27    > if __name__ == "__main__":
28    >     MyApp().run()
29    >
30    > Key features:
31    > - `@rumps.clicked()` decorator handles menu item clicks
32    > - `rumps.alert()` shows popup dialogs
33    > - `rumps.separator` creates menu separators
34    > - Runs as a persistent menu bar app
35    
36

 1    
 2    import rumps
 3    import time
 4    from threading import Thread
 5    
 6  class FocusTimer(rumps.App):
 7      def __init__(self): [10 lines folded]
18    
19        @rumps.clicked("Start")
20      def start(self, _):
21          if self.running:
22                return
23    
24            self.running = True
25            Thread(target=self.tick, daemon=True).start()
26    
27        @rumps.clicked("Reset")
28      def reset(self, _): [3 lines folded]
32    
33      def tick(self):
34          while self.running and self.remaining > 0:
35                minutes = self.remaining // 60
36                seconds = self.remaining % 60
37                self.title = f"{minutes:02d}:{seconds:02d}"
38    
39                time.sleep(1)
40                self.remaining = 1
41    
42          if self.remaining == 0:
43                self.running = False
44                rumps.notification("Focus timer", "Done", "Time for a break.")
45    
46  if __name__ == "__main__":
47        FocusTimer().run()
48

Line 8, Column 15 qwen3-coder:480b @ 135 tok/s ~/Desktop/focus-timer Scratch Pad Generic-Default

Works offline

No accounts. No telemetry. No cloud dependency. Your license is verified locally.

Instant typing

Type without lag, even in very large files. Koi minimizes editor-side input latency to keep editing responsive.

See latency benchmarks →

AI that runs on your machine

Connect local models through Ollama for code completion and inline chat. Your code stays on your computer.

Works with any AI coding agent

Claude Code, Aider, Codex, or your own tools. Koi automatically reloads external file changes across every window.

Feels like a Mac app

Native menus, shortcuts, drag-and-drop, and window management. Everything behaves the way you'd expect on macOS.

Automate it with Python

Write your own commands in plain Python, assign shortcuts, and use them like built-in editor features.

Flexible workspaces

Open files side by side, split them into horizontal panes, or detach tabs into separate windows.

Every view stays in sync automatically, even when the same file is open across multiple windows.

Private AI completions

Run local models with Ollama, keep your code private, and choose the one that fits your machine and workflow.

AI-powered code suggestions are designed to stay fast, unobtrusive, and integrated into your editing workflow.

Inline shell and chat

Run shell commands or chat with a local AI without leaving your editor. Send the current selection as a prompt and stream the response back into your document.

Custom editor commands

Extend Koi with plain Python instead of learning a plugin framework.

Write editor commands, bind them to shortcuts, and use them like built-in features.

Use cases

Zero-latency typing

Koi maintains a measured P95 typing latency of 17.86 ms while editing a 1 million-line Odin source file with syntax highlighting enabled.

Offline AI for sensitive codebases

Koi works with local Ollama models, no account, no telemetry, and no cloud fallback. Use AI code completion even on restricted or air-gapped machines.

Native Mac editing with local AI

Koi is a native macOS code editor built for fast typing, private Ollama completions, Python customization, and offline-first development workflows.

Roadmap

What we're currently working on, and recently shipped.

Local-AI rework

Tab multi-select

Multi-cursor editing

Multiple views, single document

Mix-and-match local LLMs

Copilot-like code completion

Project-wide search

Context-aware autocomplete

Custom editor commands

Code scroller (minimap)

Emacs-like org mode for notes

In-code shell and Python eval

Hand-tuned native lexers for fast, precise syntax highlighting.

Assembly

Bash

Basic

CSS

Clojure

C++

Dart

Diff

Elixir

Fortran

Gleam

Haskell

HTML

Jai

Java

JavaScript

Julia

JSON

Kotlin

LaTeX

Lua

Makefile

Markdown

MATLAB

Mojo

Nim

OCaml

Odin

Org

Pascal

Perl

PHP

Prolog

Python

Ruby

Rust

Scala

Solidity

SQL

Swift

TOML

TypeScript

WAT

YAML

Zig

Submit feature request

We're 100% user-funded

Supported by you No incentive to add anything the editor does not need

Personal Early bird

$195 ~~$325~~

One-time payment

Single user

Unlimited machines

Commercial use

Buy once, own forever

Buy personal

Teams

$595 /year

For up to 10 users

Up to 10 users per license

Unlimited machines per user

Commercial use

One-year expiry

Buy for teams

Business

$5995 /year

For larger organizations

Unlimited users

Unlimited machines per user

Commercial use

One-year expiry

Buy for business

Licensing FAQ.

Why should I buy a license?

Koi Editor is free for non-commercial use. If you use it for work, a commercial license is required. That is how development is funded.

What is non-commercial use?

Non-commercial use includes learning, personal projects, hobby use, and evaluation. If you use Koi Editor for paid work, company work, client work, or any other commercial activity, a commercial use license is required.

Which license is right for me?

The Personal license is for one individual user. Teams and Business licenses are for organizations and multi-user use.

Working alone and using it professionally: Personal

Buying for a small group: Teams

Covering a larger organization with one license: Business

Can I use my Personal license at work?

Yes. A Personal license can be used for commercial work if you are the only person using the software. For multi-user use, choose Teams or Business.

When should we choose Business instead of Teams?

Teams is designed for smaller groups and covers up to 10 users per license. If you need to cover more users, you can either increase the Teams license quantity at checkout or move to Business at renewal.

I lost my license file, where can I get a new one?

You can recover your license file on license.hackerman.ai, using your Session ID displayed to you after purchase.

We can also help you recover your license, send an email to koi@hackerman.ai and include any information relevant to your purchase, such as email, name, business name, approximate date and time.

A product by Hackerman, Inc.

End User License Agreement Privacy Policy

Your text editor for code

Roadmap

We're 100% user-funded

Your text editor
for code