A calm, fast editor with a real terminal inside.

Luna is a macOS code editor built on Zed. It runs Ghostty's terminal engine, keeps your Claude Code and Codex limits in view, learns which completions you pick, and keeps language servers lean.

Download for macOS View on GitHub

Windows version coming soon

luna main/ main

use anyhow::{Context as _, Result, anyhow, bail};
use chrono::{DateTime, Utc};
use futures::AsyncReadExt as _;
use http_client::{AsyncBody, HttpClient, Request, StatusCode};
use serde::Deserialize;
use std::sync::Arc;
use crate::{RateLimited, UsageReport, UsageWindow};
/// The endpoint Claude Code's `/usage` reads. It isn't a public API, so it may change.
const USAGE_URL: &str = "https://api.anthropic.com/api/oauth/usage";
const OAUTH_BETA: &str = "oauth-2025-04-20";
/// Windows Claude reports, in the order they're shown, with their short labels.
const KNOWN_WINDOWS: [(&str, &str); 4] = [
("five_hour", "5h"),
("seven_day", "wk"),
("seven_day_opus", "Opus"),
("seven_day_sonnet", "Sonnet"),
];
#[derive(Deserialize)]
struct StoredCredentials {
#[serde(rename = "claudeAiOauth")]
oauth: Option<OAuthCredentials>,
}
#[derive(Deserialize)]
struct OAuthCredentials {
#[serde(rename = "accessToken")]
access_token: String,
/// Milliseconds since the epoch.
#[serde(rename = "expiresAt")]
expires_at: Option<i64>,
#[serde(rename = "subscriptionType")]
subscription_type: Option<String>,
}
/// Fetches usage with a Claude Code sign-in, as stored in its keychain item.
1 reference
pub(crate) async fn fetch_usage(
stored_credentials: &str,
http_client: Arc<dyn HttpClient>,
) -> Result<UsageReport> {
let stored = serde_json::from_str::<StoredCredentials>(stored_credentials)
.context("couldn't read Claude Code's sign-in")?;
let credentials = stored
.oauth
.ok_or_else(|| anyhow!("Claude Code uses an API key, which has no usage limits to show"))?;
// Refreshing the token here would rotate the one Claude Code stored and sign it out.
if credentials
.expires_at
.is_some_and(|expires_at| expires_at <= Utc::now().timestamp_millis())
{
bail!("sign-in expired; run claude once with this account to renew it");
}
let request = Request::get(USAGE_URL)
.header(
"Authorization",
format!("Bearer {}", credentials.access_token),
)
.header("anthropic-beta", OAUTH_BETA)gk7734, 18 hours ago • Show Claude and Codex usage and switch their accounts from the status bar
.body(AsyncBody::empty())?;
let mut response = http_client.send(request).await?;
let mut body = String::new();
response.body_mut().read_to_string(&mut body).await?;
match response.status() {
StatusCode::OK => {}
StatusCode::UNAUTHORIZED => bail!("sign-in expired; run claude once to renew it"),
StatusCode::TOO_MANY_REQUESTS => return Err(RateLimited.into()),
status => bail!("usage request failed with {status}"),
}
let mut report = parse_usage(&body)?;
report.plan = credentials.subscription_type.map(Into::into);
Ok(report)
}
7 references
fn parse_usage(body: &str) -> Result<UsageReport> {
let usage = serde_json::from_str::<serde_json::Value>(body)?;
let object = usage
.as_object()
.ok_or_else(|| anyhow!("unexpected usage response"))?;
let window = |key: &str, label: &str| -> Option<UsageWindow> {
let window = object.get(key)?.as_object()?;
Some(UsageWindow {
label: label.to_string().into(),
used_percent: window.get("utilization")?.as_f64()? as f32,
resets_at: window
.get("resets_at")
.and_then(|resets_at| resets_at.as_str())
.and_then(|resets_at| DateTime::parse_from_rfc3339(resets_at).ok())
.map(|resets_at| resets_at.with_timezone(&Utc)),
})
};
let windows = KNOWN_WINDOWS
.iter()
.filter_map(|(key, label)| window(key, label))
.collect::<Vec<_>>();
if windows.is_empty() {
bail!("the usage response had no usage windows");
}
Ok(UsageReport {
windows,
plan: None,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_usage() {
let report = parse_usage(
r#"{
"five_hour": { "utilization": 12.0, "resets_at": "2026-10-21T15:00:00+00:00" },
"seven_day": { "utilization": 28.5, "resets_at": "2026-10-25T09:00:00Z" },
"seven_day_opus": null,
"seven_day_sonnet": { "utilization": 0, "resets_at": null }
}"#,
)
.unwrap();
let summary = report
.windows
.iter()
.map(|window| {
(
window.label.to_string(),
window.used_percent,
window.resets_at.map(|resets_at| resets_at.to_rfc3339()),
)
})
.collect::<Vec<_>>();
assert_eq!(
summary,
vec![
(
"5h".to_string(),
12.0,
Some("2026-10-21T15:00:00+00:00".to_string())
),
(
"wk".to_string(),
28.5,
Some("2026-10-25T09:00:00+00:00".to_string())
),
("Sonnet".to_string(), 0.0, None),
]
);
assert!(parse_usage("{}").is_err());
}
#[test]
fn test_reads_stored_credentials() {
let stored = serde_json::from_str::<StoredCredentials>(
r#"{ "claudeAiOauth": { "accessToken": "test-token", "expiresAt": 1, "subscriptionType": "max" } }"#,
)
.unwrap();
let oauth = stored.oauth.unwrap();
assert_eq!(oauth.access_token, "test-token");
assert_eq!(oauth.subscription_type.as_deref(), Some("max"));
}
}

❯ git log --oneline -3

9f9368e Update Luna from its GitHub releases

5683076 Pack Luna into a DMG with a drag-to-install window

c9327da Rainbow indent guides in the theme settings, and pin JSX elements with sticky scroll

❯

162:1Rust

This is a working mockup with Luna's own source. Open files, scroll the code, type in the terminal, or click the usage meter.

Only in Luna

What you won't find in another editor.

A terminal that behaves like a terminal.

The built-in terminal runs on libghostty-vt, the engine inside Ghostty. vim, tmux and claude get the same key handling, colors and mouse modes they get in a standalone terminal, and any folder opens in a Ghostty window from the project panel.

Terminal panel · Project panel → Open in Ghostty

❯ git status

On branch main

M crates/ai_usage/src/claude.rs

M crates/ai_usage/src/codex.rs

Type help, or try git log.

❯

Your AI limits, one glance away.

The status bar shows how much of your Claude Code and Codex five-hour and weekly limits you've used. Add more than one account and switch from the menu; Luna swaps which account Claude Code is signed in to.

Status bar → usage menu

5h 17% 2h 30m · wk 30% 4d 7hwk 11% 29d 23h

Pick an account, add one, or remove one. Example accounts and numbers.

Completions that learn what you pick.

Luna indexes every symbol in your project in the background and offers them next to the language server's suggestions. Names you've picked before come first, weighted by how often and how recently. The index is cached, so reopening a project only reads the files that changed.

Any file → start typing

pub(crate) async fn install_login(login: Option<&ClaudeLogin>) -> Result<()> {
match login {
Some(login) => {
let account_name = claude_code_account_name().await?;
write_password(CLAUDE_CODE_SERVICE, &account_name, &login.credentials).await?;
write_oauth_account(login.oauth_account.clone())
}
None => {
delete_all_passwords(CLAUDE_CODE_SERVICE).await?;
write_oauth_account(None)

Nothing picked yet, so names are ranked by how well they match.

Pick a name further down the list. When the same letters are typed again, it comes first.

Language servers that use less memory.

ESLint runs inside TypeScript's server instead of starting its own, rust-analyzer stops analyzing every crate up front, and a server that grows past 6 GB restarts once it's been idle for five minutes.

Default settings, nothing to set up

Zed's defaultsLuna

TypeScript project−33%

Editor and language servers, on an Expo app

1.36 GB

0.91 GB

Rust project−45%

rust-analyzer after start-up, on Zed's own repository

7.3 GB

4.0 GB

Under the hood

Small changes that keep a long day light.

Servers only while they're useful

Prettier stops after ten minutes without formatting and comes back on the next format. Tailwind's server starts only in projects that use Tailwind.

Checks only what you saved

On save, rust-analyzer checks the package you edited instead of the whole workspace.

Backs off on battery

Symbol indexing waits while Low Power Mode is on or the Mac is running hot, then catches up.

Quiet when idle

Luna stops drawing frames when nothing on screen changes, and the cursor stops blinking after ten seconds, so an idle window lets the CPU sleep.

Memory goes back to macOS

Every 30 seconds Luna hands memory it has freed back to the system instead of keeping it reserved.

Pause a whole project

One toggle stops file scanning, file watching and language servers for a huge folder. Turn it back on and Luna catches up.

Install

Download Luna

Version 1.26.0 · Release notes

macOS

For Apple Silicon Macs (M1 or later). Signed and notarized by Apple.

Download .dmg85 MBor use Homebrew

brew install --cask gk7734/tap/luna

Windows

A Windows build of Luna is on the way.

Coming soon

Once installed, Luna checks its releases and updates itself.

Open a project tonight.

Download Luna for macOS