Er Studio v0.1.7

Long Press Now Works Like Hardware

The input pad now features a Long Press button that behaves exactly like the physical hardware. Press and release are separate events (long_press, long_press_release), matching the SDK's LONG_PRESS_EVENT (9) and LONG_PRESS_RELEASE_EVENT (10). No more single-click hacks — hold-to-confirm and progress-while-held interactions now work correctly.

The button stays lit while pressed and releases on pointerup, pointercancel, or window blur, so a press can never get stuck.

Simpler Action Validation

server/sim.js no longer maintains a hard-coded allow-list of input actions. Instead, it validates the shape of an action (lowercase snake_case) and lets the simulator be the authority on which actions exist. New simulator actions work immediately without requiring an ER Studio release.

GET /api/sim/actions lists known actions for reference. Unknown actions return as their own 4xx and surface as a toast pointing to the upgrade.

---

Docs Buttons Now Work Inside VS Code

Docs buttons were never broken links — they just couldn't open in the webview. Every DOCS button is an <a target="_blank">, but the panel page lives inside an iframe within a webview, which can't open top-level windows. The click was silently swallowed with no error.

Now: a single delegated handler in public/app.js catches http(s) link clicks when the page is framed and posts them up as er-open-external. Both webview shells relay that to the extension host, which validates the URL (parsed, http/https only) and opens it with vscode.env.openExternal. If nothing acks within 500ms — meaning the page is framed by something other than the extension — it falls back to window.open instead of eating the click twice.

Since it's delegated, every docs link works: doctor fixes, SDK reference symbol and member links, and anything added later — no per-link wiring required.

---

SDK Reference Tracks npm, Not the Build

This was the release-blocker: the SDK reference previously had two sources — the .d.ts in the selected project's node_modules and a snapshot baked into the repo at build time. Every Even SDK release forced a new ER Studio release.

New Resolution Order:

1. The SDK installed in your project — what your code actually imports; wins whenever it exists
2. The latest published SDK — pulled from the npm registry at runtime
3. The bundled snapshot — for offline use and first run

Behind the Scenes:

server/npm-fetch.js queries the registry and unpacks the tarball in memory. No new dependencies (it's a small ustar reader), no npm subprocess, nothing written into your projects. Results cache to ~/.er-studio/sdk-ref/ with a 6h TTL and single-flight, so ten panels don't mean ten downloads. Refresh runs in the background whenever something is already servable; every failure falls through silently to what you had — an offline laptop must not turn the panel into an error. Reload forces a re-check.

Two Knock-On Wins:

• /api/sdkref/dts serves the latest published types when a project has no node_modules yet, so Monaco completion on bridge. works before the first npm install
• The payload carries latestPublished / updateAvailable, so the panel shows "0.0.15 published" instead of you finding out later

Doctor's overlayStale Check Updated:

The check dropped from warn to pass-with-note. Under the new model, the hand-written English overlay lagging the SDK is the normal state of the world on the morning of every Even release — signatures are always current, only the prose lags — and a check that cries wolf on schedule is one you learn to ignore.

---

Theme Coherence — Panels Now Adopt Your VS Code Theme

The panels now adopt your VS Code theme instead of a fixed palette.

Light Themes Work Now

Before, light mode was faked with filter: invert(0.92) hue-rotate(180deg), which produced colors matching no real theme, inverted every image by hand to undo itself, and made the panels obviously not part of the editor.

Now they are. Open a light theme — Dark Modern, Monokai, High Contrast, or anything else — and the panels repaint themselves in place. No reload, no flicker; your terminal's scrollback and the mirror's live canvas stay put.

How It Works

The panels are served from a different origin than the webview, so VS Code's --vscode-* variables couldn't reach them by inheritance. A bridge now relays them in: the webview wrapper enumerates every theme variable and posts them into the framed page. The panels re-declare them as CSS custom properties, and everything resolves against them.

Because every token carries the old ER color as its fallback, running npm start without VS Code looks exactly as it did.

Theme-Aware Rendering

The three things JS paints — Monaco, xterm, and the metrics sparklines — now read the live theme too:

• Monaco derives its editor chrome from the workbench theme. Syntax tokens are an honest approximation: strings and numbers borrow the colors the debug views use for the same things; keywords borrow symbolIcon.keywordForeground.
• xterm gets all sixteen ANSI slots from --vscode-terminal-ansi*, so ls matches the integrated terminal.
• Sparklines now use globalAlpha instead of patching the color string, so they work with hex, rgb(), and rgba() tokens alike.

Side Effects

• Button copy is sentence case (RUN → Run, PACK .EHPK → Pack .ehpk), matching the workbench.
• The Google Fonts link is gone. IBM Plex is now a fallback; inside VS Code you get --vscode-font-family and --vscode-editor-font-family. The panels also render offline and under a strict CSP.
• refreshTheme() is now a no-op. Theme switches used to reload the iframe and discard the terminal's scrollback. They now repaint in place.
• The simulator mirror is not themed. A 576×288 mono green framebuffer is what the glasses show; tinting it to match Solarized would be a lie about the hardware.

---

Notes

• The exact automation action string for long press could not be verified: npm blocks fetching and the docs don't publish the action list. long_press / long_press_release mirror the SDK event names. If Even chose otherwise, it's now one attribute in index.html, not a server patch.
• apps/vscode/core/ has been re-vendored from packages/core/.
• Run apps/vscode/test/run.js and the package script locally before shipping; neither could run here (no express, no network).

---

Installation

Download the .vsix below, then in VS Code open the Extensions sidebar, click the … menu at the top, and choose Install from VSIX.

Or from the command line:

code --install-extension er-studio-0.1.7.vsix

## Requirements

• Node 18+
• Even Hub tooling:

npm i -g @evenrealities/evenhub-simulator @evenrealities/evenhub-cli

Feedback

Issues and pull requests welcome. If you're reporting a problem, run ER Studio: Open Doctor Report and include the report, plus the output of ER Studio: Show Logs.

Er Studio v.0.1.6

Theme coherence — the panels now adopt your VS Code theme instead of a fixed palette.

Light themes work now

Before, light mode was faked with filter: invert(0.92) hue-rotate(180deg), which produced colours matching no real theme, inverted every image by hand to undo itself, and made the panels obviously not part of the editor.

Now they are. Open a light theme — Dark Modern, Monokai, High Contrast, or anything else — and the panels repaint themselves in place. No reload, no flicker, your terminal's scrollback and the mirror's live canvas stay put.

How it works

The panels are served from a different origin than the webview, so VS Code's --vscode-* variables couldn't reach them by inheritance. A bridge now relays them in: the webview wrapper enumerates every theme variable and posts them into the framed page. The panels re-declare them as CSS custom properties, and everything resolves against them.

Because every token carries the old ER colour as its fallback, running npm start without VS Code looks exactly as it did.

Theme-aware rendering

The three things JS paints — Monaco, xterm and the metrics sparklines — now read the live theme too:

• Monaco derives its editor chrome from the workbench theme. Syntax tokens are an honest approximation: strings and numbers borrow the colours the debug views use for the same things, keywords borrow symbolIcon.keywordForeground.
• xterm gets all sixteen ANSI slots from --vscode-terminal-ansi*, so ls matches the integrated terminal.
• Sparklines now use globalAlpha instead of patching the colour string, so they work with hex, rgb() and rgba() tokens alike.

Side effects

• Button copy is sentence case (RUN → Run, PACK .EHPK → Pack .ehpk), matching the workbench.
• The Google Fonts link is gone. IBM Plex is now a fallback; inside VS Code you get --vscode-font-family and --vscode-editor-font-family. The panels also render offline and under a strict CSP.
• refreshTheme() is now a no-op. Theme switches used to reload the iframe and discard the terminal's scrollback. They now repaint in place.
• The simulator mirror is not themed. A 576×288 mono green framebuffer is what the glasses show; tinting it to match Solarized would be a lie about the hardware.

Install

Download the .vsix below, then in VS Code open the Extensions sidebar, click the … menu at the top, and choose Install from VSIX.

Or from the command line:

code --install-extension er-studio-0.1.6.vsix

You'll also need Node 18+ and the Even Hub tooling:

npm i -g @evenrealities/evenhub-simulator @evenrealities/evenhub-cli

Feedback

Issues and pull requests welcome. If you're reporting a problem, run ER Studio: Open Doctor Report and include the report, plus the output of ER Studio: Show Logs.

Er Studio v0.1.5

ER Studio is now a VS Code extension!

ER Studio started as a standalone Electron application. It isn't one any more.
The mirror, the Doctor, the SDK Reference, the consoles and packaging all run inside VS Code now, next to the code you're actually writing.

The parts VS Code already does well it keeps: the editor, the terminal, window management. ER Studio does the parts that are specific to building for the G2.

This also means no more unsigned application. No quarantine attribute, no "damaged and can't be opened", no Apple Developer account required.

A layout, not a pile of panels

Clicking the ER Studio icon arranges the workspace for you:

• Left — the ER Studio controls, with your projects tree directly underneath, so writing code and driving the simulator no longer means switching between two sidebars.
• Right — Simulator and Webview as editor tabs, sized like any other editor.
• Bottom — Console, Simulator Console, SDK Reference and Doctor, each its own tab.

Move anything wherever you like; ER Studio: Reset Layout puts it back.

Run and Stop live on the simulator

The simulator tab has its own toolbar with Run, Stop, Restart and Capture, next to the thing they act on, along with the name of the project currently loaded.

A much faster mirror

Every embedded panel was running the whole UI's polling loops, so five open panels meant five copies of the 60 Hz screenshot poll, each fetching and decoding a PNG that nobody was looking at.

Each panel now runs only what it needs, the mirror is paced by the frame clock instead of a fixed interval and pauses when it isn't visible, pixel analysis is limited to the metrics panel, and the server coalesces frame requests, so twelve simultaneous callers cost the simulator one fetch instead of twelve.

SDK Reference

The reference loads itself when you open it, and follows your cursor again: put the caret on a symbol in a .ts or .js file and the reference jumps to that entry. Matching is forgiving, so glasses.sendText finds sendText. Untick "follow cursor" in the panel if you'd rather browse.

Doctor

Doctor keeps its own tab and writes nothing to the Problems panel, which stays about your code.

It no longer warns about node-pty: the extension doesn't ship a terminal, because VS Code already has a better one, so a missing native module for a panel that isn't there was pure noise.

Setup asks first

On the first run in a workspace, ER Studio asks where you want your G2 projects to live and only offers to create one if that folder is empty. Nothing is scaffolded without confirming, and the folder you pick is written to erStudio.workspace, which is the same one Doctor checks. Previously the server and Doctor could disagree about which folder was in use.

It also recovers your login shell's PATH before starting anything. A VS Code launched from the Dock inherits launchd's environment rather than your shell's, which is why evenhub-cli, nvm and Homebrew could be invisible to the extension while working fine in a terminal.

A walkthrough

ER Studio: Get Started covers the layout, the projects folder, running on the simulator, Doctor, the reference and packaging. It's offered once on first run.

Install

Download the .vsix below, then in VS Code open the Extensions sidebar, click the … menu at the top, and choose Install from VSIX.

Or from the command line, if you have the code command on your PATH:

code --install-extension er-studio-0.1.5.vsix

You'll also need Node 18+ (Even's docs ask for 20 LTS or 22+) and the Even Hub tooling. Doctor will offer to install these for you, or:

npm i -g @evenrealities/evenhub-simulator @evenrealities/evenhub-cli

macOS is the tested platform. Nothing is deliberately mac-only, but Linux and Windows are unverified.

Building from source

git clone https://github.com/gabrielevierti/er-studio.git
cd er-studio

npm install
npm run package    # builds the .vsix into apps/vscode/
npm test           # runs the test suite

To work on the extension itself, open apps/vscode in VS Code and press F5. That loads it from source, so edits are one reload away.

npm start still serves the complete UI at 127.0.0.1:4477 in a browser, editor and terminal panels included. That's also what ER Studio: Open Full UI in Browser opens.

Notes

Problems, Output and Debug Console are built into VS Code and can't be removed by an extension. ER Studio never writes to them, and you can hide them by right-clicking any tab in the bottom bar.

The Electron desktop app has been removed. It remains in the git history if you need it.

Feedback

Issues and pull requests are very welcome, especially from anyone with real G2 hardware, which I still don't have.

If you're reporting a problem, run ER Studio: Open Doctor Report and include the report, plus the output of ER Studio: Show Logs. Between them they carry most of what's needed to investigate without having to ask for it separately.

An independent community project, not affiliated with or endorsed by Even Realities.

Er Studio v0.1.4

Better Doctor, improved SDK Reference, dockable and movable panels, UI improvements, the bug fixes and improvements referenced in issue #13

Dockable and movable panels!

Panels can now be docked, resized, rearranged, and moved outside the main application window. This also makes it possible to use panels on a second monitor.

The panel layout is preserved so your workspace can be arranged to fit your workflow.

Better Doctor

The Doctor panel has been improved and now includes a Run Fixes button, allowing detected problems to be fixed directly instead of requiring commands to be run manually.

SDK Reference

The SDK Reference tab now provides a working Official Docs button, making it easier to jump from a symbol in the editor directly to the corresponding official Even Realities documentation.

Other improvements

This update also includes various UI improvements, bug fixes, and other changes described in [issue #13](#13).

Install

Download the .dmg below and drag ER Studio to Applications.

The current release is arm64 only. If you're using an Intel Mac, build it from source instead.

The app is unsigned, so macOS may refuse to open it the first time with the misleading "damaged and can't be opened" message. The application is not actually damaged; it has simply not been notarised by Apple, which requires a paid Apple Developer account.

Try opening it once and let macOS block it. Then go to:

System Settings → Privacy & Security → Open Anyway

If the Open Anyway button does not appear, you can remove the quarantine attribute manually:

xattr -dr com.apple.quarantine "/Applications/ER Studio.app"

On first launch, macOS will also ask for permission to control System Events. This is used for the window-hiding functionality. DOCTOR checks for this permission as well and reports what functionality will be unavailable without it.

Building from source

git clone https://github.com/gabrielevierti/er-studio.git
cd er-studio/er-studio

npm install
npm run app        # run it
npm run dist       # build a .dmg into dist/

Feedback

Issues and pull requests are very welcome, especially from anyone with real G2 hardware, which I still don't have.

If you're reporting a problem, open DOCTOR and press COPY REPORT. That report contains the information needed to investigate most issues without having to ask for it separately.

An independent community project, not affiliated with or endorsed by Even Realities.

ER Studio v0.1.3

SDK Reference, right inside the editor, where it matters

This time, just one addition — but an incredibly useful one.

When writing code, it is often useful to consult the official documentation written by Even Realities to check what each function, class, interface, enum, etc. does, how it can be used, and what its parameters and behavior are.

In this update, I added exactly that: a built-in SDK reference, with a way to search for symbols and browse their documentation without leaving the editor.

SDK Reference Tab

A new REFERENCE panel is now available in the dock.

It essentially acts as a browsable reference for the current SDK version, containing the definitions and documentation for the symbols available in the SDK.

Here you can see a couple of screenshots:

---

There is also a counter showing the number of symbols currently available in the SDK, a Copy button for quickly copying a symbol's name for further research, and an Official Docs button that opens the corresponding page in the official Even Realities documentation.

Install

Download the .dmg below and drag ER Studio to Applications. It's arm64 only — on an Intel Mac, build from source instead.

The app is unsigned, so macOS refuses to open it the first time, usually with a misleading "damaged and can't be opened". It isn't damaged; it just hasn't been through Apple's notarisation, which requires a paid developer account. Try to open it once, let it fail, then go to System Settings → Privacy & Security and click Open Anyway. If that button doesn't appear:

xattr -dr com.apple.quarantine "/Applications/ER Studio.app"

On first launch macOS also asks for permission to control System Events — that's the window-hiding mechanism. DOCTOR checks for that permission too, and tells you what you lose without it.

Building from source

git clone https://github.com/gabrielevierti/er-studio.git
cd er-studio/er-studio
npm install
npm run app        # run it
npm run dist       # or build your own .dmg into dist/

Feedback

Issues and pull requests very welcome — especially from anyone with real G2 hardware, which I still don't have.

If you're reporting a problem, open DOCTOR and press COPY REPORT. That one paste carries everything I'd otherwise have to ask you for.

An independent community project, not affiliated with or endorsed by Even Realities.

ER Studio v0.1.2

Stop guessing why it isn't working.

Two additions, both aimed at the same problem: the first hour with the G2 toolchain is almost entirely environment setup, and when something is misconfigured the failures are silent. RUN starts Vite and then nothing happens. The mirror stays dark. PACK fails on one manifest rule at a time. Nothing tells you which of a dozen things is actually wrong.

Environment doctor

A new DOCTOR panel in the dock. It checks your whole local setup and reports each result as pass, warn or fail — with a plain sentence explaining what it breaks in practice, and the exact command or doc link that fixes it.

Fifteen checks across five groups:

• Host — operating system, with macOS-only features called out on other platforms
• Toolchain — Node version, npm, and whether the npm global bin directory is on the PATH
• Even Hub tooling — simulator install and version, an actual launch probe of the binary, the packaging CLI, whether port 9898 is free, npm registry reachability
• ER Studio — ~/.er-studio.json validity, workspace permissions, node-pty, macOS automation permission
• Project — dev and build scripts, installed dependencies, SDK version against the declared range, and app.json validated against the documented evenhub pack schema

Two of those deserve a note.

The PATH check walks the PATH that ER Studio actually spawns with, not the one your login shell has. When Node is missing from the first but present in the second, it says so specifically: installed, but not on the PATH ER Studio was launched with. That's the classic Finder-launch gap — nvm and fnm are the usual culprits — and it's a completely different fix from "not installed". It also catches the case where you ran npm i -g but the global bin directory isn't visible, so ER Studio has been silently falling back to npx and running a different version than the one you installed.

The manifest check validates app.json offline against the full pack schema: package_id format, edition, the 20-character name limit, semver, permissions-as-an-array-of-objects, language codes, and whether entrypoint actually exists inside your build folder. You get every problem in one list before PACK runs, instead of one CLI error per attempt.

Severity tracks what you're trying to do rather than tidiness. A missing dev script fails, because RUN is dead without it. A missing build script only warns, because it just blocks PACK.

COPY REPORT flattens everything to plain text with your home directory redacted, ready to paste into Discord or a bug report — OS, Node version, tooling versions and every misconfiguration in one message.

Checks run once at launch (toggleable), on demand, or one at a time. Re-running a single check doesn't restart anything, and switching projects re-runs only the four project rows.

SDK version in the status bar

The status bar now reports which Even Realities packages are actually installed, and tells you when they disagree.

Three versions matter and they can drift apart independently: the simulator and CLI installed globally, and the SDK inside whichever project you have selected. The status bar shows the project SDK version by default, but promotes a tooling problem above it when one exists — because a missing simulator breaks RUN, and that outranks a version number as the thing you need to know.

It understands the details that bite:

• Packages resolved from the npx cache are reported as working, not as errors — that's a legitimate setup, just a slower one
• A simulator older than 0.7.0 is flagged specifically, because that's the version that added the automation API the entire live mirror is built on. Below it, RUN starts and the mirror stays permanently blank with no error
• ^0.x ranges are compared correctly: with a zero major, the minor is the breaking-change axis, so ^0.0.12 genuinely does not accept 0.0.13. Every Even package is still on 0.x, so this is the normal path rather than an edge case
• Git URLs, file: paths and compound ranges return no verdict instead of a guess — a false mismatch warning trains people to ignore the badge

Hover for the full picture across all three packages, including any newer versions on npm. When the toolchain is broken, clicking it opens DOCTOR.

The status bar and the doctor share one detection path internally, so they can't disagree with each other.

Install

Download the .dmg below and drag ER Studio to Applications. It's arm64 only — on an Intel Mac, build from source instead.

The app is unsigned, so macOS refuses to open it the first time, usually with a misleading "damaged and can't be opened". It isn't damaged; it just hasn't been through Apple's notarisation, which requires a paid developer account. Try to open it once, let it fail, then go to System Settings → Privacy & Security and click Open Anyway. If that button doesn't appear:

xattr -dr com.apple.quarantine "/Applications/ER Studio.app"

On first launch macOS also asks for permission to control System Events — that's the window-hiding mechanism. DOCTOR checks for that permission too, and tells you what you lose without it.

Building from source

git clone https://github.com/gabrielevierti/er-studio.git
cd er-studio/er-studio
npm install
npm run app        # run it
npm run dist       # or build your own .dmg into dist/

Feedback

Issues and pull requests very welcome — especially from anyone with real G2 hardware, which I still don't have.

If you're reporting a problem, open DOCTOR and press COPY REPORT. That one paste carries everything I'd otherwise have to ask you for.

An independent community project, not affiliated with or endorsed by Even Realities.

Er Studio v.0.1.0

Write code, press RUN, and see the glasses display next to your editor.

ER Studio is an integrated development environment for Even Realities G2 smart glasses. Editor, file explorer, live glasses display, simulator control, console, terminal, metrics and packaging — all in one window.

It doesn't replace the official Even Hub toolchain, it orchestrates it. Under the hood it drives the real evenhub-simulator, the real Vite dev server and the real evenhub-cli. You just never have to touch them directly.

What's in it

Project lifecycle — scaffold from the official evenhub-templates, one-click RUN that starts Vite and launches the simulator against it, one-click PACK that produces the .ehpk ready for the developer portal.

Editor — Monaco, fully vendored so it works offline. TypeScript and JavaScript IntelliSense, plus highlighting for HTML, CSS/SCSS, JSON, Markdown, YAML, XML and shell. File explorer backed by a filesystem watcher, so the tree keeps up when scaffolds finish or terminal commands touch files.

Live glasses display — a real-time mirror of the simulator's framebuffer, pulled over its HTTP automation API. The simulator window is hidden the moment it appears; you develop against the mirror inside ER Studio and never look at it again.

Debugging — TouchBar input pad injecting real gesture events, the simulator console streaming your app's own logs and uncaught exceptions, a unified process log, and a metrics panel with boot-to-first-render, lit pixel count and frame delta.

Nothing is emulated and nothing is faked: the pixels are the simulator's pixels, the input is real input, the logs are your app's real logs.

Requirements

• macOS on Apple Silicon. The .dmg below was built on an M3 and is arm64 only. On an Intel Mac, build from source instead — it's the same app, it just needs compiling on your machine.
• Node.js 18 or later
• The Even Hub tooling, ideally installed globally:

  npm i -g @evenrealities/evenhub-simulator @evenrealities/evenhub-cli
  

  Without it, ER Studio falls back to npx on first run, which is slower.

Getting started

1. Install it below, or clone and npm run app.
2. Point it at your projects folder: create ~/.er-studio.json containing { "workspace": "/Users/you/dev/even-projects" }.
3. NEW → pick a template → RUN → watch the lens come alive.

Installing

Download the .dmg below and drag ER Studio to Applications.

The app is unsigned, so macOS refuses to open it the first time — usually with "damaged and can't be opened", which is misleading. It isn't damaged. It just hasn't been through Apple's notarisation, which requires a paid developer account.

To open it:

1. Try to open the app once and let it fail.
2. System Settings → Privacy & Security, scroll down, and click Open Anyway next to the ER Studio message.

If that button doesn't appear, clear the quarantine flag directly:

xattr -dr com.apple.quarantine "/Applications/ER Studio.app"

On first launch macOS also asks for permission to control System Events. That's the window-hiding mechanism — without it the simulator window stays visible.

Building from source

Required on Intel Macs, and the quickest way to get changes in.

git clone https://github.com/gabrielevierti/er-studio.git
cd er-studio/er-studio
npm install
npm run app        # run it
npm run dist       # or build your own .dmg into dist/

Feedback

Issues and pull requests very welcome — especially from anyone with real G2 hardware, which I don't have. If you're reporting a problem, your macOS version, your Node version and the relevant chunk of the process log make it much faster to fix.

An independent community project, not affiliated with or endorsed by Even Realities.