Hard not to agree :) It's why we're building Hexana — so people and AI can read the true "source code": the compiled binary that actually runs, not just the text we wrote. Source is intent, the binary is truth. x.com/elonmusk/status/2084304083851034949

Elon Musk (@elonmusk) on X

This is exactly right. Source code is on the verge of becoming like assembly. The next step is getting rid of “source code” entirely and just making an efficient binary directly with AI.

x.com

Hexana VS Code 0.8.0: semantic section highlighting and section navigation for WASM and native binary files, a Dependencies tab for WebAssembly Component binaries, and Save As for nested modules and ZIP entries. #WebAssembly #VSCode [link card: marketplace.visualstudio.com/items?itemNa...

Top tab now shows a size diagram for WebAssembly and native binaries: largest entities ranked by byte size. Fixes in 0.15: the empty Dominators tree regression, Go to Source for Rust modules, and a rare UI freeze on the Decompiled tab.

Exception-handling visibility: try_table, throw, and throw_ref decode in WAT with tag and label comments. Click a throw to jump to its handler, or see it marked as escaping to the host. New Tags tab. New Exceptions tab showing the module's panic surface.

Go to Source context menus land in the Functions, Exports, and WAT views. Works via DWARF or a source map. Source maps are discovered from the sourceMappingURL custom section (Kotlin/Wasm, Emscripten) with a .map sidecar fallback. #wasm

Hexana 0.15 for JetBrains IDEs: call_indirect dispatch candidates in the WAT view, a Dispatch diff tab, Go to Source from WAT and Functions, exception-handling visibility, and a size diagram for the Top tab. #WebAssembly #IntelliJ

Every call_indirect and return_call_indirect row in the WAT view shows statically known dispatch candidates: functions in the table whose type matches the call site. The Dispatch diff tab shows which candidates entered or left the table between two builds, grouped per signature.

Also in 0.14: a data inspector panel showing the selected byte as integers, floats, binary, octal, ASCII and UTF-8, with an endianness toggle. Select a byte in the hex view and the panel decodes it.

Two more for native binaries: a size diff action comparing two native binary files section by section (byte deltas sorted by impact), and semantic section highlighting that color-codes sections in the hex view and adds jump navigation between them. Works for both WASM and native formats.

WebAssembly Component Model gets a Dependencies tab. Open a .wasm component and see which components depend on which, as a diagram inside the IDE. Good for navigating layered component graphs without flattening everything to text. Thanks @lukewagner.name for suggestions #wasm

The fix was in the data structures, not a bigger heap. Dominator results moved to a compact int buffer instead of boxed hash maps. Indirect-call edges went from callers-times-table (hundreds of millions on Emscripten modules) to linear via a synthetic node. memory64 modules included.

OpenUSD's usdviewweb.wasm: 50MB, 42k functions, memory64. It used to drive IntelliJ past 10GB into OOM. Hexana 0.14 opens it, renders the Functions tab, and finishes garbage analysis, all inside a default 2GB heap. #WebAssembly #IntelliJ [link card: plugins.jetbrains.com/plugin/29090...

We expose 49 deterministic analysis tools over MCP. Feed a WebAssembly binary to an AI agent and it gets structured facts — exports, imports, sizes, types — not raw bytes. Binary intelligence as a protocol, not a guess. #WebAssembly #MCP #DevTools

We added WebAssembly run configurations and debugger support to the VS Code extension. Set breakpoints in the WAT view, inspect locals and globals when they hit. WebAssembly debugging without leaving VS Code. ext install JetBrains.hexana-wasm #WebAssembly #VSCode

Search Everywhere in IntelliJ now finds exports and functions inside your binary files. Type a WebAssembly function name, jump to it in the module — same shortcut you already use for code. Binaries become navigable project members. #WebAssembly #IntelliJ

ELF, Mach-O, PE — Hexana parses them and disassembles x86-64, AArch64, and RISC-V via Capstone. DWARF 4/5 debug info included. Native binary support inside IntelliJ, same tab model as WebAssembly. #IntelliJ #DevTools #WebAssembly

Two small Hexana releases today. JetBrains plugin 0.13.1 adds a Decompiled tab for .class files. VS Code 0.6.1 brings the virtualized WAT view to Component Model binaries. Polish, not drama. #WebAssembly #DevTools [link card: marketplace.visualstudio.com/items?itemNa...

We ship a JVMTI agent that captures JVM JIT-compiled machine code at runtime. Open the .jit file in IntelliJ and see bytecode next to the x86-64 or AArch64 output HotSpot actually produced. No external profiler required. #JVM #IntelliJ #DevTools

Building with Kotlin/Wasm? Hexana detects Kotlin-produced WebAssembly modules and badges them, so your Kotlin/Wasm output opens as a structured module: functions, WAT, sizes. Made at JetBrains, so Kotlin/Wasm is close to home. #Kotlin #WebAssembly #IntelliJ

When we detect a GraalVM Web Image inside a .wasm file, we demangle function names back to Java symbols. The "Java" badge in the Functions tab jumps straight to the bytecode view. GraalVM + WebAssembly tooling that speaks both languages. #GraalVM #WebAssembly #IntelliJ

We built a dominator treemap and a semantic diff that shows size impact per function across two WebAssembly builds. Which change bloated the module? Now you can see it without grepping objdump output. #WebAssembly #IntelliJ #DevTools

We added inline row editing to the WAT view and multiple data-display modes so you can inspect a data segment as hex, decoded text, or raw bytes without leaving the IDE. WebAssembly editing inside IntelliJ. Not what you expected from an IDE plugin. #WebAssembly

Our WAT tab virtualizes rendering so an 35 MB WebAssembly module with 14 000 functions doesn't lock the UI. Row editing, multiple data display modes, instant scroll. The binary is the source of truth; we just make it readable. #WebAssembly #IntelliJ

We've been building a tool that makes compiled binaries first-class citizens in IntelliJ and VS Code — not a hex editor or disassembler, but an IDE companion. WebAssembly, GraalVM images, JARs, native ELF/Mach-O — all structured, navigable, searchable. #WebAssembly #DevTools