LiquidityMapperFast
Open it: https://liquiditymapper.com/ — free, no sign-up, MIT licence. A one-minute tour inside shows you around (offered on a first visit, and the Guide's first button), and the Guide explains everything. A market-map workbench for one coin at a time across many venues: BTC, or any of about 150 coins listed on most of them (see Coins below). It runs entirely in the browser: the page reads the exchanges' public feeds itself, in a Web Worker, so it works from any static host (GitHub Pages included) with no server. A local server remains as an optional source with a week of recorded history. The workbench draws a liquidity heatmap built from recorded order-book depth, a price profile, an aggregated order-book ladder, depth and open-interest panes, and a footprint of executed volume. The look follows the reference screenshots inexample_images/ (a local folder, not in git); a right-hand profile column and an OI row complete it.
The default venues are the largest ones whose public order book is also deep, fresh and reliable: Binance, Bybit, OKX, Bitget, Hyperliquid and Deribit perpetuals, plus the spot markets of Binance, Coinbase, Bybit, OKX and Bitget (Research_Findings.md has the measurements and the rule; Gate.io and MEXC are big by reported volume but are left shallow on purpose: Gate.io publishes no book beyond about 15 bp and reports about twice the volume it was seen to trade, and MEXC's deep book is three to five times Binance's near the price on a quarter of its trading, so it would dominate the map; see the 2026-10-12 section there). In the browser the Venues picker offers these eleven and MEXC, which is off until chosen: a page can read only its best 20 levels (its REST sends no CORS header), and its resting book is several times heavier than its trading (Research_Findings.md, 2026-10-08). Each has a connector in src/shared/venues.ts and the choice is kept in this browser's localStorage. With the local server the picker offers 29 (the 20 feed venues plus the spot markets of Binance, Bybit, OKX and Bitget, and Binance US, HitBTC, Poloniex, BitMart and Bitunix, which run on small self-contained connectors) and up to 32 feed venues can be enabled; its Recommended button ticks the default set, and nothing changes until Apply. The choice is saved beside the history database (v2-feed-venues.json for the feed venues, v2-venues.json for the connector venues) and restored when the server restarts, so an existing install keeps its venues until Recommended is applied (a recommended venue added by a later build starts once, in the browser and on the server, since the saved choice records which venues it had seen); on the first run the recommended venues are selected (HLM_DEFAULT_VENUES=all selects every supported venue and starts every connector, HLM_DEFAULT_VENUES=configured keeps the venues set by the *_ENABLED flags and starts no connector venue instead). A fresh start needs about 30 s before market metadata allows the selection to apply. Everything reads public exchange feeds from your own machine (the browser, or the local server); no order is placed and nothing is sent to any service of ours. Optional HyperTracker credentials stay on the server, which is why those layers are listed as upcoming in the browser-only page.
Run
``powershell
cd HyperLiquidMap
npm install
npm run dev:client # the page alone, reading the exchanges from your browser: http://localhost:5173
npm run build:site # typecheck + the static site in dist/ (HLM_SOURCEMAP=off leaves out source maps)
npm run preview:site # serve dist/ to look at it
npm run dev # build + local server with a week of recorded history on http://127.0.0.1:8787
npm run dev:fixture # the server with offline demo feeds
`
Which source the page uses. A static host has no server behind it, so the page reads the exchanges itself (src/app/browser-source.ts, the engine in src/shared/engine.ts running in src/app/browser/feeds.worker.ts). Served by the local server, the page finds api/v2/state on its own origin and uses the server instead, with its recorded history. ?source=browser or ?source=server forces one; ?persist=0 stops a browser session from keeping recordings. The browser keeps the last 24 hours of recorded depth, executions, large trades, liquidations and open-interest readings in IndexedDB, written by one tab at a time (a Web Lock), and the heatmap marks where its recording begins: a page can only record while it is open. The engine starts on the live feeds at once and reads those recordings, and the recorded history of the day before, meanwhile: the book, the price, the trades and the flow move within a couple of seconds of opening, and the heatmap's history (with the other recorded panes) fills in when it has been read. A returning page reads the map's last three hours first (about a fifth of a second, where the whole day takes three) and draws the window it opens on from them; the rest of the day comes with the other panes. Before that day the heatmap's depth comes from the long history (BTC, from 2026-11-01 on, kept for good): the history service folds every book's minutes into windows of 2 to 4,096 minutes as the page merges them and serves them as tiles, so a view that reaches before the page's own day draws its columns at two minutes or coarser from them, fetched for the view as it moves; the page's own minutes take over where they begin (src/app/archive/). ETH and SOL have heat-map history too (a trial, from when the service began recording their books): the service records their books as tiles alone, from 8-minute windows up, so their views before the page's day draw at eight minutes or coarser (the finest level the service's latest.json names for the coin), a live view too until the tab has recorded the whole of it (their hours bring no book minutes for the day). Depth only: the flow, trades and footprint keep the day. See docs/deployment.md for publishing.
PORT, HISTORY_DB (SQLite; the depth recorder writes depth-v2.sqlite beside it) and QUOTA_FILE choose where state lives. To try a change without disturbing a running instance, start a second server on another PORT with its own HISTORY_DB. The server answers only requests addressed to localhost or an IP address and, for a browser, only from its own page, so another website you visit cannot drive it (HLM_ALLOWED_HOSTS=name1,name2 adds public names for a deliberate deployment; docs/deployment.md covers going public, GitHub Pages and what can be protected). HLM_SOURCEMAP=off leaves source maps out of a published build.
npm test builds and runs the Node suite, npm run typecheck runs the three strict TypeScript projects, npm run test:wasm runs the Rust kernel tests, and npm run build:wasm regenerates the committed WASM glue (needs wasm32-unknown-unknown and wasm-bindgen-cli 0.2.129).
Using it
| Gesture | Effect |
| --- | --- |
| Wheel on the chart | Zoom time and price together, by the same factor, so the picture keeps the shape you gave it (a limit on one axis stops both, and only the turn that would go past it: a chart framed wider than the price limit is held by a turn out and zoomed by a turn in, never driven the wrong way): about the live edge and the current price while the map follows the market (so it swells and shrinks around them instead of sliding), about the point under the pointer on a map you have moved by hand. Alt holds the pointer too, and takes the map off the live point as a drag does (else the current price would pull the scale back from under it). The wheel on the time labels along the bottom zooms time alone |
| Wheel or drag on the price scale | Zoom the price axis about the current price while it is on the map (the pointer turns to a resize arrow over the scale; the wheel over the profile column beside it zooms price too); drag up zooms in, down zooms out; Alt + wheel zooms about the pointer (and takes the map off the live point) |
| Shift + wheel | On the chart, zoom time alone (what the wheel did there before it zoomed both), held as the wheel holds it; on the price scale, time instead of price |
| Drag / Shift+drag | Pan both axes / time only (on the time labels along the bottom, time only) |
| Drag or wheel on a pane under the chart | Pan or zoom the time axis every pane shares with the chart, a maximized pane too (the wheel as on the time labels: about the live edge while following, else the pointer); a drag starts past 4 px, so clicks on a pane are unchanged, and never moves price |
| Double-click, R, Home, Recenter | Return to the live edge |
| Go to (map corner, G) | A date and time on the page's clock: the map is centred on it at its zoom (and fitted to the candles there). It says how far back the depth and the candles go (the chart holds its last 500 candles: at 1m that is about eight hours, so further back the candles are the exchange's history, read for the view, with the depth and footprint the recording has); an earlier moment goes to the start of them, a later one to the live edge |
| Replay (Go to → Replay from here) | Plays what was recorded back as if it were live, from the moment chosen, at 1×, 10×, 60× or 300×, with a bar on the map (pause, speed, the moment, Live). The map, its candles (the one under way rebuilt from the recorded price a second), the trades, the panes under it and the flow column show what was known then; what came after is covered. Not shown: the order book (recorded only as the map's minute columns), the profile column and the dot rows; the footprint, bar statistics and open interest of a candle appear once it has ended. Sounds and alerts are silent; a replay that catches up is live again |
| Price line | The dashed line at the last price and its tag on the price axis are in the colour of the candle under way (rising or falling; the order book's price row too), and under the tag a box counts down to the candle's close (UTC-aligned, as the exchanges close them) |
| Layouts (the map's corner; Settings on a tablet) | Arrange the panes, choose a ready-made layout or keep your own. The panel says which layout the screen is showing and whether it has been changed since, and holds six ready-made layouts (Default, Map only, Order book, Order flow, Positioning, Everything) and your own as cards, each a picture of its panes drawn from the layout itself; saving ("With the chart's settings" keeps the timeframe, the heatmap's colours and every switch as well; without it a layout keeps which panes are open, where they stand and how big they are), rename, duplicate, update and delete; the panes one by one; and a file to write them to and read them back. Never the coin, the venues, the theme, the time zone, the sounds, the VWAP anchors or the Volume profile's zone and anchors. Applying a layout, hiding a pane and deleting a layout offer Undo, which puts back what that changed (the panes if nobody has moved them since, and each setting a saved layout carried that still stands as it left it) and leaves what you did in the meantime. Kept in this browser. On a shorter window the panes under the map shrink in proportion so the map keeps at least 30 % of the column (and its own minimum), and get their heights back on a taller one; this also applies when the window is resized. See Layouts and the places of the panes below |
| Keys (Keys in the status bar, or ?, lists them) | 1–7 the timeframes 1m to 1d, R / Home recenter, + / − zoom time, F T L A P O K V H switch Footprint, Trades, Liquidations, Absorption, Volume profile, TPO, Key levels, VWAP and Highlights on or off, U folds the TPO into its profiles or lays it out in time, X arms Range (Esc cancels), D the drawing tools (Delete removes the drawing selected, Ctrl+Z / ⌘Z undoes, Ctrl+Shift+Z or Ctrl+Y redoes), S screenshot. Not while typing in a field or a window is open, nor with Ctrl, Alt or ⌘ held (but for Undo and Redo) |
| Right-drag | Right / up zoom the time / price axis in; left / down zoom out |
| Order book: wheel, drag the price column, drag the book, double-click | The wheel zooms the book about the current price (Alt + wheel, or a book you have scrolled off the price, zooms about the pointer) by changing the price step per row (the Group select follows; Auto shows the step it is using); dragging the price column up zooms in and down zooms out, about the same point as the wheel (the price stays put on the middle row while the book is centred; Alt, or a book scrolled off the price, zooms about the pointer); a spin of the wheel makes at most four steps a second, one per event however many clicks it folds in, and a touchpad at most three (a gentle swipe is still a step), so one flick is a step or two and not the whole list; dragging the book moves it; double-click returns to Auto and the mark. Shift + wheel still scrolls Single mode sideways |
| Splitters, grips, the ⋯ menu | Resize the two columns and the panes under the map (a focused splitter moves with the arrow keys, 16 px a press, 64 with Shift; a double click gives a column back to the window, and the panes a splitter under the map parts their own height); drag a pane by its grip, or by its header where it holds no control, to move it: a side pane to either side of the map (a column that is not there yet shows a strip along the window's edge to drop on), a pane under the map between the others; the ⋯ menu (or a right click on a header) offers the same moves for a keyboard and a finger: to the other side, up, down, swap the two sides, reset the size; places and sizes persist |
| Hover (profile column or order book) | Mirror: the band from the mark to the pointer and the equally wide band on the other side are framed with border lines in each side's colour and labelled with their cumulative size and distance, the rest dims, and a box says which side has more and by how many times: the order book's with what each band holds ("Opposite side has 1.13x more"), the profile column's and the liquidation column's naming the heavier side in its colour ("asks 1.08× the bids", "longs 1.60× the shorts", or about even within 2 %); move outward to watch the balance change. In Single mode the order book compares within the hovered venue's book. The chart itself shows no comparison. Switched with Mirror in the order book's Cues panel (on by default; it left the Panels deck on 2026-11-12, where clicking it changed nothing until one hovered) |
| Hover | Shared time cursor across chart, depth, OI and Delta; price and liquidity readout on the chart |
| Flow column: hover, wheel or drag, double-click | A time cursor runs down the column and a box says what the row under the pointer did (the lanes' running delta there, net flow, buys against sells over the ranking window, share of volume; the top row also says when spot and perpetuals move apart); the wheel or a drag scrolls the exchange rows under the pinned top rows when they do not all fit; double-click scrolls back to the top. Map, 5m ... 24h in its header choose the time span, the gear the ranking, row heights and re-ranking |
| Flow, Book (top bar), × on a pane, [ and ] | Show or hide the two side columns; a pane's × hides it and a column with nothing open leaves an edge tab that opens it again; [ and ] hide or show the left and the right column (matched by their place on the keyboard, so where a bracket needs AltGr the keys there do it: Ü on a German keyboard, whose right-column key is the zoom's +, so its edge tab does that one); a column that was closed with its key comes back with the panes it had open; on a phone Flow is a tab that fills the area. The venue chips show eleven venues and put the rest in a "+N" menu grouped by exchange; the bar along the bottom of a desktop page shows the connection, venues live, the price and its age, since when it records and where the data comes from, with the language and theme buttons |
| Hover (order-book cell or bar) | A box says that venue's size, its share of the level, its rank at the price and its distance from the mark; over the USD column or a plain bar it says the whole level with the venues behind it. The Mirror's box steps aside while the pointer is directly on one (its band stays) and returns anywhere else |
| Hover (order-book row, mouse) | The row's price is drawn across the map and its columns in its side's colour (its prices shaded where the grouping is wider than a few pixels there), with the price the book writes for it on the map's axis (at the axis's end, with an arrowhead, when the map does not show that price), and across the flow column's price strip when the window's prices reach it: the order book follows into the chart as the panes under the map follow the map's pointer |
| Hover (footprint row) | The row is boxed and a card gives its price span, what was sold and bought, the delta, which side was heavier and by how much, its share of the candle, whether it is the point of control, and the candle's own volume and delta (a trade bubble or a trapped-traders pop-up takes precedence) |
| Hover (bar-stats cell) | The cell is boxed and its candle's column and its row are tinted; a card says the statistic, the candle, the value, the candle before, where it ranks among the candles in view, whether it was flagged unusual, and what the statistic means |
The toolbar selects the market, timeframe (1m–1d), layer (a menu only once there is more than Liquidity to choose), heatmap source (aggregated or one venue), Spot / Perp / Both, the venues (the Venues button says how many are on and opens their switches and the feeds dialog), heatmap colour (Size ramp or two-hue Sides style, a legend showing the USD range with one Contrast slider, and at its end a settings key whose panel holds the colour range (Auto or Off) and the smoothing (Auto or Off), rows of their own in a phone's Settings), the Profile / Depth / OI / Delta / LT / Volume toggles (the page opens with the map, the flow column and the order book only, the panes under the map one switch away; the two columns begin at the golden section of the window, 19 % of it each, and follow it until a column is dragged), Footprint (a lamp button with its own panel), Trades, Liquidations and Absorption (marks on the map), Volume profile, Key levels and VWAP (lines on the map), Highlights and Sound (what is unusual), each a split button: the button switches the feature on or off and its lamp says which, and the small key joined to its right (drawn sliders) opens the feature's settings, which stay as they were while the feature is switched; and the theme menu (hover a theme to preview it, click to keep it). On a desktop the toolbar is a console of framed decks (Market, Time, Heatmap, Panels, Chart, Alerts and the page's own), one row at its own size from about 1,620 px wide in English, scaled down to stay one row (to 85 %, which 1,366 px needs) on a smaller screen, and under that as few rows as fit (two, three on a narrow window), broken where the longest row is shortest so that no deck is left alone on a row (in rows Alerts stands beside Heatmap: Market, Time, Heatmap and Alerts over Panels, Chart and the page's own, which makes two rows even), each row reaching both edges with its decks grown in proportion and their controls spread across them, and nothing in it moves or changes size as data comes and goes. The flow column and the order book are 19.1 % of a wide window each, and narrower ones (to 260 and 350 px) on a window under 1600 px, so the map keeps its room on a laptop. Each kind of control looks like what it does: pane switches glow while their pane shows, the chart type glows while the price is drawn, features wear a lamp and a settings key, choices are segments or lists, and the buttons that only open something (Guide, Author, the screenshot) have neither. The ladder offers Compact (the default), Aggregated and Single modes, a grouping step and Levels / Cumulative / both; in Compact, Venue lines (off, top 3, 5 or 8; 5 by default) draws each of the largest venues' running total from the mark on a linear scale of their own (full width is the largest of them in view, with round-value gridlines), ranked by traded volume over the flow column's ranking window, and hovering a line shows it alone with its numbers (where a line crosses a bar it is a faint trace under the bar's labels, so the bars stay readable); and Pull/stack (off, 15 s, 1 min or 5 min): a column after LEVEL USD with how much resting liquidity each row gained (+, stacked) or lost (−, pulled) over that window, grey where the price traded in the window (a fill there looks exactly like a pull). It compares snapshots of every venue's book, counting a venue at a row only where its book reached the whole row both times; a venue that reconnects rebuilds its book and reads as a burst of both, and a coarse venue's banded levels spread their change over the rows they cover. The Liquidation levels, Stop loss and Take profit layers are not offered yet, and the Layer menu stays out of the bar and Settings until one is (2026-11-12; before, it listed them as upcoming): they need HyperTracker data, which a static page cannot hold a key for. Liquidations (positions the exchanges closed by force) are drawn as diamonds where the market was, from Binance (its latest each second only), Bybit, OKX and Deribit; Hyperliquid, Coinbase and spot markets publish none, and the panel says which of the venues switched on report them. Key levels draws the previous day's, week's and month's high, low and middle and each period's open (PDH, PDL, PDM, DO and the W and M ones), from one market's hourly exchange candles going back about two months; a previous level not yet traded through runs on, dotted, until price reaches it. VWAP draws the volume-weighted average price of the session (each day, week or month, with optional ±1σ/±2σ bands), rolling VWAPs over the last 1 to 365 days and up to four anchored VWAPs a coin, placed by clicking the map, from the chart market's exchange candles or from markets you choose (see VWAP and anchored profiles); the whale VWAP averages the recorded large market orders (from a size you choose), buys and sells apart.
Liquidation levels (Liq levels in the Chart deck, BTC only) draws the prices that would liquidate Hyperliquid's open BTC positions: HyperTracker's position snapshots (about one every 30 minutes), binned by the levels service (HyperLiquidMap_Levels, a separate Rust project) into $10 rows of long liquidations (in the falling-candle colour, below the price) and short liquidations (rising-candle colour, above it). They are a stripe right of the newest candle, so the heatmap keeps its own colours: the more a row holds the darker it is, with a crisp edge on the strongest, and a diamond marks a row where one position holds at least half. A snapshot describes the positions about 35 minutes before HyperTracker stamps it; from then on a level goes as Hyperliquid's price trades through it (its 1-minute candles, which can run a few basis points past the mark price liquidations use, and the chart's own price at once, so a move made before the page opened is taken too); snapshots older than three hours are not drawn. The page asks for a new snapshot when it can be there: the levels service asks HyperTracker 2,300 s after the held snapshot's creation (then every 3 minutes while the next is not ready), so the page asks from 37 minutes after it, each minute until it comes, every five minutes once 52 minutes have passed, and not at all while the page is out of sight; a snapshot seen to appear between two asks is placed without reading the page's clock and teaches the page how far its clock is off; until then a clock that is off makes the first few snapshots late, never missed (about four requests a snapshot instead of thirty; src/app/liq-schedule.ts). Their own column, between the map and the profile column, adds them up: what still stands in each row and the two cumulative curves (an X request of 2026-11-12, after CoinMarketCap's liquidation map), everything from the price out to each price, lightly filled behind the bars with their edge drawn over them; wherever the map's crosshair is (or the pointer on the column with Mirror off) the column reads the curve there, a dashed line, a dot on the curve and "how far · what goes on the way" (onTheWay in liq-levels.ts, which the stripe's "If price gets here" uses too; the compact map's strip has no curve); hovering it compares the longs below with the shorts as far above, as Mirror does for the book (a switch in the button's panel hides it). Pointing at a level gives what is at it, its distance, how much would be liquidated if price got there, the number of positions and the largest, and the isolated / cross split. The note under the legend says when the positions were taken (Powered by HyperTracker), and the Guide has a section on it. An indicator's values join the map's hover box only when the pointer is on what it drew.
The levels' history, and Plus. History, a small button under the liquidation column's heading (out of sight while the Depth pane already shows it), opens the Depth pane on Liquidation levels: the same levels through time, a snapshot about every half hour, in the pane's bands. That history is free for today and the 7 UTC days before it (FREE_DAYS, src/app/plus/config.ts); what is older is part of Plus, the page's paid part (2026-11), which pays for the servers behind it. Without Plus the pane does not ask for the older days at all: it hatches that stretch faintly, ends it on a dashed line and puts a button there, Earlier history: Plus, a page element over the drawing that opens the presentation of Plus. The rule is the server's (the levels service answers a paid day only to a request that carries a valid pass, which it checks itself; the HyperLiquidMap_Plus project, a Cloudflare Worker, only signs the passes); the page knows it only so as to say it, and where the server refuses a day the page's clock called free (a clock that is off), that day and the ones before it are closed too. Plus also opens what the levels show beyond the liquidations of all traders, in the Levels control (src/app/levels-control.ts: the button at the top of the liquidation column opens it, and so do the Liq levels panel, the Depth pane's levels button and the title of the phone's Liq tab): three switches, liquidations, stops and take profits, any of them together and one always on (the curve adds up the liquidations and the stops that are on; take profits sit on the other side of the price, so they are never added: dashed bars beside the curve, or on alone a dashed curve of their own), and whose levels they are for every kind, everyone's or HyperTracker's +PnL traders' (the wallets in HyperTracker's four cohorts with a positive all-time perp profit; their stops and take profits come from files of their own, and where the server has none yet the page says they are not available yet, never drawing everyone's in their place). Split, in the same control, draws the column as two (Plus): liquidations beside stops on one scale, or everyone beside the +PnL traders each on its own, where the map has room for both (else the two added up, or everyone's, and a note), and the stripe gives each column a lane of its own, captioned the same way (beside a column too narrow for everyone beside the +PnL traders, everyone's alone); a kind the split needs switched off draws one column and keeps the split for when it is on again. The Depth pane is not split: it draws the levels as without a split (Liquidations | Stops as Liq + stops, Everyone | +PnL as everyone's levels). It is one choice for the page (src/app/liq-view.ts), and the stripe, the column, the Liq tab and the Depth pane follow it; without Plus the page draws liquidations of all traders and keeps the choice, locked, for when Plus comes back, and a lock opens the presentation and changes nothing. A Depth view wider than 120 days reads the four-hour rollups with Plus. Details: docs/plus.md.
Plus has no account. After the checkout the browser holds a key and a pass (src/app/plus/pass.ts, localStorage lmf.plus): the pass is a short-lived signed note sent as Authorization: Bearer with each request for a Plus file, the key asks the server for a new pass before the old one runs out (POST ), and a pass the server refuses is dropped and asked for again, never more than one renewal a minute across every open tab (the wait is kept beside the membership); a pass's end is judged by the server's clock where the device's is off, and only the server's refusal counts as an ended membership (Plus.state: none, on, checking, ended). The app and the Plus page share that storage, so a tab of the app is unlocked the moment the Plus page stores a membership (a storage event). The app loads no other site's script: the checkout (Paddle, the seller of record) and the form that finds a membership by its receipt are on a page of its own, plus/. A key can be entered on either: the app's Plus pop-up and its presentation send it to the same renewal, and take the answer only for the membership it was sent under (src/app/plus/key.ts). That page is on the app's origin, since the two share the membership's storage, so Paddle's script, once a visitor presses a price there, runs where the key is kept: the one other site's code this origin ever runs, and the seller's own (src/app/plus/page.ts, built by vite.plus.config.mts after the app so that the app's own files stay what they were), beside the three pages a seller owes its buyers (terms/, privacy/, refunds/: plain HTML in src/app/public/, English only). While Paddle's token or the monthly price in config.ts is empty, Plus is not on sale and both pages say so; the page then closes no day by itself (every day is asked for, and only the gate's own refusal closes one), and the Plus page still takes a key (one given as a gift). Plus in the page's own deck (where the Tour stood until 2026-11-17: one more button would have broken the bar into two rows on a 1,366 px screen; the Tour is the Guide's first button and the first visit's invitation, and a tile of a phone's Settings) opens, for a browser without a key, the presentation of what Plus adds (a sheet with the demo on made-up numbers, fetched when it first opens; the Plus page opens on the same hero, demo and sections), and for one with a key a small status pop-up: until when Plus runs, the key with Reveal and Copy, Replace key, and Remove from this browser, which does not cancel a subscription. The button is lit while Plus is on. ?plus=http://127.0.0.1: lets a local stand-in answer for the Plus server while testing, as ?levels= does for the levels file. Details: docs/plus.md.
A venue that never connects, keeps failing and fails a plain request while others work is shown as unavailable from the visitor's location: a dashed chip, a dismissible banner and a status in the Venues dialog say that a VPN set to another country may enable it.
The chips are the venues that have a book on the map. A venue that was chosen but has none gets a dashed chip of its own, so it never just disappears from the toolbar: a red-tinted one (warning mark) for a venue that is failing or, on a server, left off the map because its book is crossed (a feed fault: "book crossed by 123 bp"), a grey one (ellipsis) for one that has been connecting for more than 20 s. Hovering it says why. A server cannot push these changes, so the page asks it every 10 s.
Help is built in. Every control has a tooltip (src/app/tip.ts), and a ? beside each pane explains it (src/app/help.ts holds the text both use). The tour (the Guide's first button, offered once to a new visitor, a tile of a phone's Settings) lights the page a part at a time and says in a sentence what each is for (about a minute: src/app/tour/, see The tour and the guide below); the Guide button opens the long version, with a contents list in groups, a search box that forgives typos and moving pictures (src/app/guide/; an address like #guide/mirror opens it at a section). Screenshot (or S) freezes the page, lets you drag a region or click a pane (the top bar takes the whole page, every open pane and the flow column included), draw on it, pixelate or blur anything private, then copy or save a PNG (src/app/screenshot/; it draws the page itself, so nothing is asked of the browser). Install appears when the browser can install the page as an app, and Author says who made it.
On a young recording the heatmap is empty left of the dashed line that marks when the recording began: nothing is drawn where nothing was recorded, so every colour on the map is real.
Phones and tablets
The page is arranged for the screen it is on. src/app/device.ts decides once, never from the user agent, and puts two attributes on that src/app/mobile.css reads:
| Attribute | Values | Meaning |
| --- | --- | --- |
| data-layout | phone, phone-landscape, desktop | How the panes are arranged. A window up to 640 px wide, or a touch screen held upright up to 900 px (a tablet in portrait), is phone; a touch screen held sideways and up to 520 px tall is phone-landscape; everything else, a tablet held sideways included, is desktop |
| data-bar | compact, full | How the controls are arranged. compact on every phone arrangement and on any touch-first screen |
- Phone (portrait): a two-row top bar (the coin, status and Settings above; timeframes and recentre below; the market is chosen in Settings), the map, one pane at a time under it, and a tab bar (Tape, Flow, Map, Book, LT, Depth, OI, Delta, L/S, Stats: what has been traded, what rests in the book, then what is worked out from both; a tab exists while its switch is on in Settings, a phone starts with Tape, Flow, Map, Book and LT, and it opens on the Tape, the first tab; a mark under the open tab slides to the one chosen). The Tape and the Flow fill the area in place of the map, and so does the Book held upright. Tapping the open tab, or Map, gives the chart the whole screen. The handle between the map and the pane resizes it (remembered per tab and orientation; a double tap resets it). Landscape: one top row, the pane beside the map, the tabs as a rail along the edge. The panes are the same elements the desktop arranges as a column, so nothing is rebuilt when the tab changes (
src/app/dock.ts), and a phone never writes the desktop's saved pane sizes.
Tape tab: the flow column's Tape, every order as it arrives, newest on top ( CvdPane.phoneView; the column stays in the page for it with the column switched off), by default (Karl, 2026-11-14: "I want this new tape to be the default"). A button right after the top bar's spacer, shown only on this tab, switches to the tape as a chart (a wave) and back (lines), a choice kept in this browser (phoneTape, never in a layout; also Settings' Tape section, its first row). The Flow tab shows only the flow lines. The chart: every trade since the page opened, as one continuous tape that never restarts and fetches nothing, so it opens at once. Each row is a price, sold at market on the left and bought on the right, its winning side shown more strongly the more it won; the order book rests either side, a rail at the right flashes where large orders arrive, and behind it runs the trail of every market order of the last 30 s, minute or 2 minutes, at the price and time it traded (filled dots buys, rings sells; whale-sized orders carry their exchange's mark). On glass the book's rows light up as liquidity stacks and dim as it is pulled, a shock running out along the bar or back in, and large orders send waves through the glass. The header says since when, from how many markets, and how long the page was hidden (a phone in the background gets no trades). Its choices (Look, Trail, Glass, Rows, Pulses) are in Settings.
Flow tab: the flow column made for a phone, filling the area. The top is a chart: the price drawn over the taker flow of every exchange added together, spot in blue and perpetual in amber, with the dollars of the flow on one axis at the left (Settings, Flow lines, gives each kind its own range instead, as every row has, to read their shapes rather than their sizes) and the price on its own axis at the right with a tag at the newest price; a time axis runs along the foot and a dotted line marks where the flow began when that was after the window did. The spans are chips (5m, 15m, 1h, 4h, 24h; there is no map to follow here), and two fingers apart or together step to a shorter or longer one. A finger along the chart scrubs it (a dot on each line, a line through every row, and the line under the header reads the time, the price and each kind's running delta), a tap pins the moment (tap again to let it go), a press held moves the pin, a drag across the rows scrolls them and a lifted finger flings them, a double tap goes back to the top. Under the chart is a row for every exchange, the biggest first, each over its own range; the legend beside the chart gives each kind's net over the window it draws, so a figure agrees with the line beside it.
LT tab: the Liquidity Tracker, with its half-life one tap away (chips for 10, 25, 50, 100 and 250 bp; the sheet's menu keeps the others) and the half of the screen under the map. It starts at 100 bp on every screen (a save that still held the old default, 10 bp, reads as 100 once).
Slim headers: the header of a pane under the map is one row on a phone: its title, the choice that is made all the time (Range, Show, Mode and Group, the half-life), and a key at the end that opens the rest as a sheet. The Book held upright has no map above it and a crosshair key of its own that brings the book back to the price.
Settings (the ⋯ button) is a bottom sheet of labelled rows holding every control that does not fit the bar: the pane switches with Trades, Liquidations and Absorption (split buttons, as on the desktop), the Tape's choices, the heatmap colours and contrast, the market and the venues, Highlights and Sound, the theme, Keep screen on, and Guide, Screenshot, Author and Install. Panels and menus become bottom sheets with a scrim; a dropdown opens the page's own menu ( src/app/touch-select.ts) in the chosen theme instead of the system's list, and nothing makes an iPhone zoom in.
Fold the bar (the small up-arrow at the bar's right end; on a desktop, on the bottom edge of the right-hand box): the top bar folds into a thin strip and the chart takes its room, as a browser's full screen hides its own bars; the strip's down-arrow brings it back. Each browser remembers its choice.
Gestures ( src/app/touch.ts recognises them from pointer positions; the recogniser is pure and tested): drag pans and carries on after the lift; pinch zooms time with the horizontal separation of the fingers and price with the vertical one, about the midpoint, so what is under each finger stays under it; dragging along an axis zooms it; tap pins the crosshair and its readout above the finger (tap again, or drag, to let go); holding then dragging scrubs it; double-tap recentres. The panes under the map share the time axis, so a drag or pinch there moves the map's time; the order book scrolls, pinches to zoom its grouping, pins Mirror on a tap and resets on a double tap. Holding any control shows its tooltip without pressing it.
Screenshot works by finger (larger handles, buttons that wrap, a Share button where the browser has a share sheet), and records a GIF of the selected area as well as a picture: 1 to 15 s on a slider, never over 15 MB, saved as a file on a desktop (browsers cannot copy a GIF) and shared on a phone. Keep screen on uses the Screen Wake Lock API, because a sleeping screen stops the recording. Install: Chrome and Edge give a prompt; iPhone and iPad get an Add to Home Screen explanation.
Cost: with the default eight venues the page received about 47 to 74 KB/s of exchange data (165 to 260 MB an hour); the three spot markets added on 2026-10-07 add about 16 % (measured side by side over three minutes: 12.8 KB/s on top of 78.6 KB/s of message text), so about 200 to 300 MB an hour with all eleven; on a 4x CPU slowdown the main thread uses about 13 % of a core with every frame on time ( Research_Findings.md). The heatmap canvas is capped at 2 device pixels per CSS pixel on touch screens.
Testing: the layouts are exercised in Chrome with a phone's size, touch events and device pixel ratio over CDP ( Emulation.setDeviceMetricsOverride with mobile: true, Input.dispatchTouchEvent). That is Chrome, not Safari: the first real-device check is the published site over HTTPS (a LAN address over plain HTTP loses Web Locks and the clipboard).
How it works
Resilience. LiveFeedManager.start() retires the old feeds before its metadata requests, so a failure in between used to leave a running server with no feed at all (Research_Findings.md). A failed start now schedules a recovery with the last configuration that finished, a watchdog restarts a start that hangs or a manager with no feed, and /api/diagnostics reports feedManager.
`
exchange feeds ─▶ LiveFeedManager ─▶ reducers (src/server/http.mts) ─▶ state
│
┌────────────────────────────────────────────────┤
▼ ▼
v2 recorder (src/server/v2) /api/v2/ws live levels
minute columns on a shared price grid (binary, ~4 Hz) + ticks
SQLite, 7-day window, footprint recorder │
│ │
▼ ▼
/api/v2/columns (binary) ─▶ raster worker + Rust/WASM ─▶ WebGL2 texture ─▶ chart
`
- Valued levels (
levels.mts): every venue book is converted to USD (contract face value, quote conversion) with the price band each level represents. Grouped books (Hyperliquid's significant figures, Deribit's grouping) name a bid group by its lower edge and an ask group by its upper edge, Hyperliquid at one step per side (its best level's); the top bid and ask groups, which share an interval, are split at the venue's last trade.
Depth recorder ( recorder.mts): every 5 s each fresh book is spread onto a shared 1-2-5 price grid (about 0.02 % of price) and averaged per minute; stale books leave gaps rather than being carried forward. Columns are sparse (only non-empty bins), bid and ask separate, persisted to SQLite and kept for seven days.
The heatmap's drawing ( src/app/heatmap/gl.ts, canvas.ts): the raster is a WebGL2 texture coloured by a shader. Where the browser gives the page no WebGL2 (hardware acceleration off, the graphics card or its driver blocked, the card failed on the site; 2026-11-14, a visitor's page stopped at "WebGL2 is required for the heatmap"), the same picture is drawn on a 2D canvas: each cell coloured as the shader colours it, by table look-up (about 40 ms for 2,600 x 1,750 cells), the image stretched over the plot with nearest-neighbour scaling, the opacity applied as it is drawn. Compared in Chrome on the page's own grid, it is 0.08 of a colour level from WebGL on average. The frame-rate meter's GPU lamp is then red, and its panel says the page draws more slowly, that Live trades and Glass are off, and how to turn graphics acceleration on.
The frame-rate meter ( src/app/fps/; Karl, 2026-11-14: an LED panel of the page's frame rate that says how to make it faster): an LED window at the desktop status bar's left end, drawn on its own canvas from sprites made once (the glow look: slanted seven-segment digits with their unlit segments, FPS and GPU in silkscreen, a lamp behind a lens, a ten-cell bar from green to red). It counts the browser's animation frames with its own requestAnimationFrame loop, only on a desktop with the tab shown: the digits are the last second's frames, the colour that against the screen's rate (green from 90 %, amber from 60 %; the rate is read from the last minute's frames: the fastest common rate, 48 to 540 Hz, whose band of 8 % holds a tenth of them and as many as each neighbour's, the rate already read staying while its band holds 6 %, so a slower rate on the same screen is learned within a minute, stray early frames and timestamp noise do not move it, a page near the threshold does not flip, and a page held at 30 is not taken for a 30 Hz screen (reviews r17 and r18; a zoom keeps the rate, only another screen learns it again. Not knowable from frame times: a page held for a whole minute at a whole fraction of a fast screen's rate that is itself a listed rate reads as that slower screen, and a clock rounded to whole milliseconds cannot tell 165, 180 and 200 Hz apart), the bar the worst frame of the last quarter second (one frame late lights a third, four frames' time all of it; it falls back by 30 % a quarter second). The lamp: green with WebGL2, red without, amber where WebGL2 could not draw the map. Hover: a sentence; a press: the panel, with the rate, the late frames of the last minute and the graphics card, what helps (by the frame rate that three seconds in four of the last minute reached, once 20 s are seen, so a stall of a few seconds or the page's loading is not a slow page; written again while the panel is open; a tip on the screen's own rate, since a 30 Hz screen reads as 60), Copy for AI: an English report of what the page measured and what to check, most likely first, which carries the browser and system, the graphics card, the screen and window sizes, processor threads and memory and the page's settings (the button's tip lists them), and the page's address only on the public site, and More in the guide, which opens the Guide's section on speed (speed in guide/content.ts: what the window shows and every step in full, for Chrome, Edge, Firefox and Safari, Windows and macOS). Like the panes, it is sized through pixelRatio() and drawn again for a sharp screenshot. It measures the page, not the Tape (the Tape's list moves on about 80 % of frames). Cost: its callback is well under 0.1 ms and each of its four draws a second 0.15 ms, with no measurable change in late frames on the live page (paired traces); on a page that would otherwise rest it keeps the browser making a frame on every beat of the screen, about 10-20 ms of main-thread time a second on a stripped page (review r17). A gap of over 10 s with the tab shown (a sleep, a screen switched off) restarts the count. It took over the red dot that said the browser gave no WebGL2.
Kernels ( crates/hlm-kernels): raster_columns turns recorded columns into a price-by-time grid (price-conserving, averaged over observed time only); spread_levels groups live levels for the profile, ladder and the live edge of the heatmap. The same spreading exists in TypeScript on the server and a test checks the two agree.
Candles and their history ( hub.ts, price-history.ts): the chart reads its last 500 candles of a timeframe and keeps them, by market and timeframe (sixteen series), so a switch shows the ones kept at once, framed, while a read brings them up to date (Karl, 2026-10-28: switching should be instant); after a series is shown the market's other timeframes are read one at a time, the nearest first, and again once they are three minutes old, and a switch to one with nothing kept clears the timeframe before rather than drawing its candles at the new spacing. A returning visitor's series is asked for as the page starts, the page does not wait for a first live price when it knows its market, and the candles are framed without waiting for the open interest's history. Where the view reaches past those candles (before them, in a hole, or while they are on their way) the exchange's own history is read straight from the exchange (Binance first; shared/price-history.ts`) at the chart's timeframe wherever one read of 2,000 bars holds the view, and drawn as candles of the chart's type, with its volume in the Volume bars, caught by the magnet and said under the pointer; a longer view draws it coarser, as a line (in weeks once its days are more than one read holds, about four and a half to five years of view), and another market's history as a dashed line. Scripts and the VWAP run on the chart's own candles only.
Heatmap colour and the Liquidity Tracker
- Size style (default): one sequential colour ramp encodes size on a log scale; bid or ask is implied by position relative to the mark. Cells below the window stay background. Sides style uses two hues by side on a linear window.
- Contrast is one slider (-100 to 100, 50 = the baseline): it slides the colour window along the size axis (right shows thinner liquidity, left keeps only the biggest walls, and the far left tones even those down, which is what many venues added together need, because their walls are huge; double-click