DEV Community: Michael

domonic 1.8.4 released!

Michael — Tue, 22 Sep 2026 10:18:14 +0000

If you're using Python and working with the DOM or HTML you may want to take a look!

https://domonic.readthedocs.io/

;

Perusal: the internet without all the 💩

Michael — Sat, 19 Sep 2026 10:44:08 +0000

Perusal: the internet without all the 💩

I've just released Perusal, a small Python tool for reading the web without most of the web getting in the way.

Modern web pages contain an extraordinary amount of stuff that isn't actually the content:

navigation
cookie banners
footers
related articles
scripts
styles
tracking
repeated links
UI chrome
adverts
framework scaffolding

Sometimes you don't want a web page.

You just want what the page says.

That's what Perusal does.

pip install perusal

Then:

perusal https://en.wikipedia.org/wiki/Domino

And instead of a giant HTML document, you get clean Markdown on stdout.

HTML in, useful text out

Under the hood the basic pipeline is deliberately simple:

fetch
  ↓
DOM
  ↓
Readability
  ↓
Turndown
  ↓
clean Markdown

Perusal uses the Python ports of Readability and Turndown I've been working on in the domonic ecosystem.

That means it isn't just stripping tags.

It first tries to identify the meaningful article content, throws away most of the surrounding page furniture, and then converts what remains into Markdown.

You can use a URL:

perusal https://example.com/article

A local HTML file:

perusal ./saved-page.html

Or pipe HTML straight into it:

curl -s https://example.com | perusal -

See how much rubbish disappeared

There's also a report command:

perusal report https://example.com

This compares the original HTML with the cleaned Markdown and gives you an indication of the size reduction and approximate token saving.

That becomes particularly interesting when the consumer isn't a human.

It's an LLM.

If I'm passing a web page into an AI system, I generally don't want to pay for it to read navigation menus, tracking markup and 400 links from the footer.

I want the useful bit.

Give it a reading goal

Perusal can also rank sections of a page against a query:

perusal https://example.com/docs \
    --query "installation instructions" \
    --max-chars 4000

The query isn't a web search.

It's more like telling the reader:

this is what I'm trying to find on this page

Perusal ranks the headings and content chunks against that goal and then applies the character budget.

So instead of blindly chopping the first 4,000 characters from a document, it can preferentially return the relevant sections while keeping them in their original page order.

That makes it useful as a very small preprocessing layer for RAG, agents and other AI tooling.

Read several pages at once

You can also throw several URLs at it:

perusal \
    https://example.com/page-one \
    https://example.com/page-two \
    https://example.com/page-three

Perusal fetches the pages and produces one Markdown digest:

# Digest of 3 pages

## Page One

...

## Page Two

...

## Page Three

...

For simple research tasks I've found this much nicer than juggling multiple blobs of HTML.

What about JavaScript sites?

By default Perusal reads the HTML returned by the server.

That's intentional. It's fast and covers a huge amount of the web.

But obviously some sites return little more than:

<div id="app"></div>
<script src="everything.js"></script>

For those there's an optional JavaScript mode:

pip install 'perusal[js]'

Then:

perusal https://example.com/app --js

This uses myjs, my Python JavaScript interpreter, to execute the page's scripts against a live domonic DOM before handing the result to Readability.

No Node process and no full browser involved.

It's obviously heavier than simply fetching HTML, which is why it's opt-in.

It accidentally became a browser too

Once I had a clean page reader I thought:

why shouldn't humans be able to use the same thing?

So Perusal also has an optional reader browser.

pip install 'perusal[browser]'
perusal browse

Or open a page directly:

perusal browse https://en.wikipedia.org/wiki/Domino

It's a deliberately small tabbed reader with things like:

tabs and history
bookmarks
incognito tabs
adjustable typography
save page as Markdown
page source
resource inspection
DNS / WHOIS information
certificate-transparency subdomain discovery

The DevTools are intentionally fairly old-school.

They're there to answer things like:

What did this page actually return?

What resources does it reference?

What domain am I talking to?

rather than pretending to be a replacement for Chrome DevTools.

And an MCP server

The other obvious consumer of clean web content is an agent.

So Perusal can expose the exact same reader through MCP:

pip install 'perusal[mcp]'
perusal mcp

It intentionally exposes just one read-only tool:

web_read(url, query?, max_chars?, timeout?)

That's it.

I didn't particularly want another MCP server with seventeen overlapping tools for searching, crawling, scraping, clicking and browsing.

Perusal does one thing:

read this web page for me.

That makes it quite easy to give an AI client controlled access to cleaned web content without handing it an entire browser.

One pipeline, three interfaces

So Perusal has effectively ended up with three ways of using the same idea:

perusal <url>

for scripts and terminals,

perusal browse

for humans,

and:

perusal mcp

for agents.

I'm still treating it as alpha software and there are plenty of rough edges, but I think the underlying idea is useful:

the web page and the information on the web page are not the same thing.

A lot of the time we can throw away an enormous amount of the former while keeping the latter.

If you want to try it:

pip install perusal

PyPI:

https://pypi.org/project/perusal/

Feedback, bug reports and weird pages that break it are very welcome.

python #opensource #ai #webdev

Python Browser needs your tokens

Michael — Tue, 15 Sep 2026 06:49:34 +0000

Friends, Wo-mans, pythonistas… lend me your tokens.

I’m building Chromonic, an experimental Python browser/rendering engine, mostly by throwing Claude at increasingly unreasonable problems:

https://github.com/byteface/chromonic/

It uses Domonic as its DOM/CSSOM and now has a Chrome-vs-Chromonic layout conformance harness, which means I can feed it real web-platform tests and objectively measure how wrong my browser is.

Naturally, I would now like to outsource that wrongness to your Claudes.

If anyone has some spare tokens and fancies joining the campaign:

cd tests/layout

Clone WPT:

git clone --depth=1 https://github.com/web-platform-tests/wpt.git

Then point Claude at a folder under WPT/CSS2 and basically tell it:

Run the tests. Find why Chromonic disagrees with Chrome. Fix it. Repeat until victory or bankruptcy.

If the problem is actually in Domonic upstream, add it to PLAN.md and patch around it locally for now.

Pick whatever CSS2 area takes your fancy. Different agents attacking different folders would be especially interesting.

PRs, battle reports, pass-rate improvements and tales of token expenditure all welcome.

The browser is unfinished, the standards are enormous, and I have made the questionable decision to see whether a small army of Claudes can brute-force CSS conformance.

Who’s in?

Chromonic (Python Browser)

Michael — Mon, 14 Sep 2026 11:52:24 +0000

I'm going to be building a browser with Python. I already have a DOM and so just need to work on a layout engine. Watch progress here...

https://github.com/byteface/chromonic/

myjs

Michael — Sat, 05 Sep 2026 16:55:17 +0000

A JavaScript interpreter for Python. Run .js files, render HTML pages headlessly, script the DOM, call native C through ffi, and reach the entire Python ecosystem from JavaScript — no Node, no browser, no build step.

pip install myjs

or, for an isolated CLI:

pipx install myjs
myjs # REPL (history, TAB completion, top-level await)
myjs script.js # run a file
myjs script.js a b # ...with ["a","b"] as globalThis.argv
myjs -e "6 * 7" # evaluate a snippet
myjs page.html # render a page headlessly -> HTML on stdout
myjs page.html -e "document.title" # ...then read the rendered DOM
myjs examples # list the bundled demos; myjs examples hn --run
myjs examples cockpit --run # a live TUI: dashboard, killable workers, raw keypresses
import myjs

myjs.eval("1 + 2 * 3") # -> 7
myjs.run("script.js")

s = myjs.Session() # an isolated global scope
s.eval("const x = 21;"); s.eval("x * 2") # -> 42

a .py file calling a .js file directly -- no bridge, no serialization

mod = myjs.import_js("math_utils.js") # export function double(x) { return x*2; }
mod.double(21) # -> 42, a real Python call into real JS
What a script can reach
DOM document, window, and ~190 constructors (URL, Headers, Event, DOMRect, TextEncoder, …). document.createElement(...).appendChild(...) builds a real tree.
Event loop Promise (all / allSettled / race / any / finally), async / await, setTimeout / setInterval, queueMicrotask. Microtasks before timers.
ES modules import / export from .js files; a bare specifier resolves to a Python module (import np from "numpy").
fetch asynchronous, thread-backed — await Promise.all([fetch(a), fetch(b)]) is genuinely concurrent. WebSocket is a real RFC 6455 client.
fs / path / sh / http read & write files (fs.readBytes(path, n) for a raw header), run shell commands, serve HTTP (http.serve(port, handler)).
struct pre-imported — struct.unpack_from(fmt, fs.readBytes(path, n)) reads a BMP/PNG/ELF header with no library.
os / process Node-flavoured — os.platform(), os.cpus(), process.argv, process.env, process.exit().
ffi call any C library through ctypes — no node-gyp, no compiler.
py callable — py("2 ** 10") evaluates Python; py.import("pandas"), py.exec(...). The whole package index.
console %s / %d / %c format specifiers, console.table, console.group, console.count / time / assert.
native dialogs prompt() / confirm() / chooseFile() / chooseFolder() — the real macOS UI, driven from JS.
clipboard readText() / writeText() — the real system clipboard, shared with every other app.
plus say / notify / open, hash, atob / btoa, localStorage
const libc = ffi.loadLibrary("c");
libc.abs.argtypes = [ffi.types.int];
libc.abs.restype = ffi.types.int;
libc.abs(-42); // 42

const rows = py.import("sqlite3").connect(":memory:").execute("SELECT 1+1").fetchall();
console.table([...py.list(py.list(rows)[0])]);
Headless HTML — render, scrape, automate
page = myjs.Page.load("https://example.com/") # a URL (fetches HTML + CSS + JS) or a local file
page.eval("getComputedStyle(document.body).color") # the fetched CSS, applied
page.fill("#search", "widgets")
page.submit("#form")
page.wait_for(".result") # pump the event loop until it appears
page.text(".result") # read it back

myjs.render("app.html", strip_scripts=True) # SSR: one call -> rendered HTML
Page.load takes a local path or an http(s):// URL. For a URL it fetches the page, every (folded into the document so getComputedStyle sees the rules), and every — all resolved relative to the page URL. <script type="module"> gets module semantics; DOMContentLoaded / load fire. It's Puppeteer without a browser — a pip install, not a 150 MB Chromium download. Command line myjs [FILE] [ARGS...] run a .js file (ARGS -> globalThis.argv), or render a .html file headlessly -e, --eval JS evaluate JS; with a .html file, against the page -o, --output FILE write rendered HTML to a file --html force headless-render mode --strip-scripts drop <script> elements after they run --gui show the resulting DOM in a native window (needs myjs[gui]) -i, --interactive enter the REPL after running myjs examples [NAME] [--run] list / view / run the bundled demos myjs REPL The REPL readline history (persisted to ~/.config/myjs/history), reverse search, and TAB completion of globals and obj.member chains. Multi-line input is auto-detected; top-level await works. Values print the way a real REPL's inspector would -- colored, wrapped past 72 columns, Map/Set/RegExp/ Date/Symbol/Promise shown natively rather than falling back to a generic dump. A live setInterval dashboard redraws in place instead of flashing the whole terminal. Commands: .load <file> (a .js, or a .html rendered into the session as page), .save, .editor, .clear, .help, .exit. Language embedding s = myjs.Session(scope={"answer": 42}) s.eval("answer * 2") # -> 84 A JS exception that escapes becomes myjs.JSError with js_name, js_line, and js_trace (the call stack). Sessions are isolated; console.log output is captured on s.console_lines. The language layer passes a curated test262-style battery — closures, classes (extends / super / fields / getters-setters / private / static), destructuring, generators, labelled break, async / await, and the Array / String / Object / Number / Math / JSON / RegExp built-ins, real ES5-style prototype chains, and Symbol. Not covered: Proxy, with. How it's built myjs is the runtime layer on top of the domonic-libs acorn port — a faithful Python port of the acorn parser, a tree-walking evaluator, and a code generator (parse / interpret / generate, so JS can go source → AST → source) — running on domonic's DOM. It ships in lockstep with domonic-libs. Full reference: docs/myjs.md. MIT licensed.

I built a C-capable, DOM-native JavaScript Runtime in Pure Python

Michael — Fri, 04 Sep 2026 01:03:36 +0000

I just released myjs on PyPI (pip install myjs or pipx install myjs).

It’s a Python-native JavaScript runtime that bridges Python’s AST capabilities, native DOM primitives (domonic), and direct C-level Foreign Function Interface (FFI) bindings into a unified JavaScript execution scope.

🌐 The Pitch
Why build another JS interpreter?

In traditional stacks, if you want JavaScript to talk to native C libraries or manipulate server-side DOM structures, you end up juggling node-gyp, C++ addon build chains, or heavy IPC bridges like gRPC/REST between Node.js and Python.

myjs collapses all of that into a single, pure-Python process.

Because myjs parses JS (via an Acorn AST engine ported to Python) and executes it directly inside Python’s host scope, JavaScript code gains direct access to:

Python’s DOM Tree: Real-time DOM manipulation via domonic.

C Libraries & Shared Memory: Direct low-level access to system .so, .dylib, and .dll binaries via Python’s ctypes/cffi.

Python Standard Library: Clean mapping between JS scopes and host OS capabilities.

🚀 Quick Demo: C Memory, FFI, & DOM in JS
Here is what running a script in myjs looks like:

JavaScript
// myjs_demo.js

// 1. Call system C functions directly from JS without compilation!
const libc = ffi.loadLibrary('libc.dylib'); // Or 'c' / 'msvcrt'

const absVal = libc.abs(-42);
const sqrtVal = libc.sqrt(2);

window.console.log('C abs(-42) =', absVal);
window.console.log('C sqrt(2) =', sqrtVal);

// 2. Manipulate a native Python DOM tree via Hyperscript h()
function h(tag, props, ...kids) {
const el = document.createElement(tag);
for (const k in props) {
if (k === 'text') el.textContent = props[k];
else el.setAttribute(k, props[k]);
}
kids.forEach(c => el.appendChild(
typeof c === 'string' ? document.createTextNode(c) : c
));
return el;
}

document.body.appendChild(
h('main', { class: 'card' },
h('h1', { text: 'Executed by myjs' }),
h('p', { text: 'Real Python DOM tree rendered from JS!' })
)
);

window.console.log('DOM Tree:', document.body.outerHTML);
Run it via pipx:

Bash
$ pipx install myjs
$ myjs myjs_demo.js
Output:

Plaintext
C abs(-42) = 42
C sqrt(2) = 1.4142135623730951
DOM Tree =

Executed by myjs

Real Python DOM tree rendered from JS!

host = Darwin arm64 | python 3.13.12
💡 Key Features
Zero C-Compilers Required: Call C dynamic libraries, allocate raw C memory buffers, and pass function pointers straight from JS. Python’s runtime handles ABI resolution dynamically.

Pure Python Portability: Embeddable anywhere Python runs—no heavy binary blobs (like V8) required.

Direct DOM Integration: Mutate real domonic Python DOM nodes from within JS scripts.

📦 Try It Out
PyPI: https://pypi.org/project/myjs/

Installation: pip install myjs or pipx install myjs

I’d love to hear feedback, feature ideas, or wild use cases from anyone interested in language runtimes, Python/JS interop, or native FFI bindings!

convert javascript to python

Michael — Thu, 03 Sep 2026 07:49:49 +0000

It's now easier to convert javascript to python than every before due to domonic! A full DOM in Python. see here:

https://github.com/byteface/domonic-libs/

Just clone this repo and tell claude what library you want to port, to make it faithful and lean on domonic's dom.py and javascript.py and bingo an hour later and a few reprompts and out pops a compatible library.

Beautiful Slop

Michael — Sun, 30 Aug 2026 11:06:05 +0000

I used AI to create a bs4 compatibility layer for domonic...

https://domonic.readthedocs.io/packages/bs4/

It's called Beautiful Slop, let me know what you think