bhāṣikā

DeepSeek V4.1 Flash

2026-09-11T00:37:19Z

DeepSeek V4.1 Flash was launched yesterday and is already available on OpenCode Go. It now has Vision support. The price change from August 16 has been partially reversed. For now:

Type	Off-peak	Peak
Cached Read	$0.003/M	$0.006/M
Input	$0.15/M	$0.30/M
Output	$0.60/M	$1.20/M

It seems that the DeepSeek V4 Flash Vision experiment was a success. One of the most important changes compared to DeepSeek V4 Flash, for those running quantized models at home, is the model size:

Metric	DeepSeek V4 Flash	DeepSeek V4.1 Flash
Architecture	MoE	MoE
Backbone Params	284B	552B
Activated Params	13B	8B/16B
Context Length	1M	1M
Precision	FP8 Mixed	FP8 Mixed

With V4, you could run Q3 quants on a 128GB RAM machine. With V4.1, you cannot.

Mēdhā Devlog 2

2026-09-10T20:36:30Z

The application was ready in a few hours. My decisions regarding the UX:

A standard header + two-panel design. No footer.
All copyright and intro stuff goes in the colophon.
The contextual In this series panel floats on the right.
The Table of Contents panel in projects floats on the right.
The contextual Further reading panel floats below these two.
The side panel flows below the main one on narrow screens.
Prev/next links and tags occupy the bottom part of a log.
Global navigation sits just below the page header.
/logs is a synonym for the latest year: /logs/2026. The annual page uses reverse chronology to list the logs.
Site pages already support templates such as {{logs:10}} and {{projects:active}}. But the rendering was needlessly dense and ugly. I cleaned that up.

Adamant Devlog 2

2026-09-09T05:47:28Z

The experiments to get sandboxing working with PonderCode suggested a direction, and I borrowed it almost wholesale for Adamant.

The prepare command produces or updates a profile in ~/.config/adamant/profiles/. A profile can be extended by another profile. And run executes the command.

BASE="sh ls cat head tail wc grep sed awk rg pwd whoami id uname find stat readlink ps kill mkdir rmdir rm cp mv env printenv which file du df mount findmnt man tee touch echo"
adamant --profile base prepare $BASE
adamant --profile net prepare --extend base -- curl
adamant --profile base run -- sh
adamant --profile base run -- ls -la /home

As Adamant presently uses readelf instead of ldd, it loses out on the discovery of all the dlopen stuff. And as it does not use strace, it cannot detect all the data dependencies of a program. So I must manually do stuff like this:

# ~/.config/adamant/profiles/base.toml
# AUTOMATIC: resolved_ro is written by `adamant prepare`; do not hand-edit.
# Hand-edited keys (extends, extra_ro, extra_rw, hosts, env) are preserved.
resolved_ro = [
    "/usr/lib/ld-linux-x86-64.so.2",
    "/usr/lib/libc.so.6",
    ...
    "/usr/bin/clear",
]

extra_ro = [
	"/usr/share/terminfo",      # ncurses/fish terminal db
	"/etc/passwd",              # username/home lookup
	"/etc/group",
	"/etc/hostname",
	"/etc/localtime",
	"/usr/lib/kitty/terminfo",
]

env = [
    {name = "TERM", value = "xterm-kitty" },
    {name = "COLORTERM", value = "truecolor" },
    { name = "LANG", value = "C.UTF-8" },
]

and this:

# ~/.config/adamant/profiles/net.toml
# AUTOMATIC: resolved_ro is written by `adamant prepare`; do not hand-edit.
# Hand-edited keys (extends, extra_ro, extra_rw, hosts, env) are preserved.
extends = "base"

resolved_ro = [
    "/usr/lib/libcom_err.so.2",
    ...
    "/usr/bin/curl",
]

extra_ro = [
    "/etc/ssl",
    "/etc/ca-certificates",
    "/etc/nsswitch.conf",
    "/usr/lib/libnss_files.so.2",  # dlopen'd, prepare can't see it
    "/etc/hosts",
    "/etc/resolv.conf",
]

and this:

# ~/.config/adamant/profiles/coding.toml
# AUTOMATIC: resolved_ro is written by `adamant prepare`; do not hand-edit.
# Hand-edited keys (extends, extra_ro, extra_rw, hosts, env) are preserved.
extends = "net"

resolved_ro = [
    "/usr/bin/node",
    ...
    "/usr/lib/libjemalloc.so.2",
    "/usr/bin/jj",
]

hosts = ["npmjs.com", "pypi.org", "opencode.ai", "github.com", "*.astral.sh", "pi.dev", "127.0.0.1:5001", "files.pythonhosted.org"]

home = "~/my/homes/coding"
user = "<user>"

extra_ro = [
    "/usr/lib/python3.14",
]

extra_rw = [
    "~/.config/uv",
    "~/.pi",
]

This is fine for most CLI tools, but is a massive PITA if you want to get headless Firefox working inside the sandbox.

The socat socket + proxy machinery was borrowed from PonderCode as-is. It has its pros and cons. The biggest con is that applications that do not respect HTTP_PROXY + HTTPS_PROXY envars do not work.

So, Adamant is mostly done. But I plan to explore veth as well as machinery to get something like Firefox working inside the sandbox.

I could perhaps get Adamant to use ldd + strace behind an --unsafe flag so that this becomes simpler. After all, my goal is to run known binaries and LLM harnesses inside the sandbox, not malware research. So executing the actual binary to figure out what it needs is not a dealbreaker.

Mēdhā

2026-09-08T07:04:58Z

Mēdhā is the static site generator that produces this website. Once I decided to build this website, I started writing down my logs as Markdown for Mēdhā. The website has not been deployed as of this writing. But it has been running locally on my machine for a day now.

My feature list for the application is pretty simple:

no-JS
content in plain Markdown
a basic metadata block
the ability to link logs together into a series
the ability to mark logs as related
tags
dated vs evergreen content (logs vs projects/essays)

Getting the UX right will be the biggest issue. After all, the placement of:

Prev/next links
Tags
Series/Related reading lists
Global navigation

matters a lot.

Xteink X4

2026-09-07T19:34:26Z

Someone occasionally posts about the Xteink X3/X4 on Hacker News, and I try to join the conversation because I like my X4 quite a bit:

It is a tiny device similar in size to the original iPhone and has a screen the size of a credit card. The body is plastic and glass. The screen is a 219 ppi e-ink module. The device runs on a low-powered ESP32 microcontroller and uses an SD card to store books. I switched to the CrossPoint firmware on day one. The battery lasts forever, and transferring books is simple because of the HTTP server CrossPoint runs on the device.

You do not need multicore processors, Android, or large batteries to read e-books.

Fair warning: the screen is delicate and might need protection depending on how you use it.

PonderCode Devlog 5

2026-09-07T02:34:41Z

The experiment worked! And it has implications for Adamant.

Part A: Dependency Resolution

As part of the brainstorming, I created a simple Python script where I hardcoded a set of binaries as part of a list and then used ldd to resolve their dependency graph. This graph was then used to build a shell script that executed Bubblewrap. This is the heart of the script:

def generate_sand_script(apps):
    """Constructs the bwrap shell script string."""
    bind_mounts = []
    libraries = set()

    # 1. Process the requested apps
    for app in apps:
        app_path = get_app_path(app)
        if app_path:
            bind_mounts.append(f"  --ro-bind {app_path} {app_path}")
            # Get dependencies for this app
            deps = get_dependencies(app_path)
            for dep in deps:
                libraries.add(dep)
        else:
            print(f"Warning: Command '{app}' not found in PATH.")

    # 2. Sort libraries for a clean, deterministic output
    sorted_libs = sorted(list(libraries))

    # 3. Build the script template
    script = [
        "#!/bin/sh",
        "set -euo pipefail",
        'REAL_HOME="$HOME"',
        'REAL_PROJECT_DIR="$(pwd)"',
        'FAKE_HOME="/home/user"',
        'FAKE_PATH="/usr/bin"',
        "",
        "",
    ]

    exec = [
        "exec bwrap --clearenv --unshare-all --die-with-parent",
        "  --tmpfs /",
        "  --tmpfs /tmp",
    ]

    # Add app bind mounts
    for bm in bind_mounts:
        exec.append(bm)

    # Add library bind mounts
    for lib in sorted_libs:
        exec.append(f"  --ro-bind {lib} {lib}")

    # Add symlinks and environment setup
    exec.extend(
        [
            "  --proc /proc",
            "  --dev /dev",
            "  --symlink /usr/lib /lib",
            "  --symlink /usr/lib64 /lib64",
            "  --symlink /usr/bin /bin",
            '  --dir "$FAKE_HOME"',
            '  --setenv HOME "$FAKE_HOME"',
            '  --setenv PATH "$FAKE_PATH"',
            '  --chdir "$FAKE_HOME"',
            '  "$@"',
        ]
    )

    return "\n".join(script) + " \\\n".join(exec)

I took this and incorporated it into the app. Now, the user does not have to manually map paths into the sandbox. They can provide a list of binaries and the system will resolve them at runtime and prepare the sandbox accordingly.

Part B: Sockets + Proxy

The app initializes the sandbox with socat running a proxy on 127.0.0.1:8080 inside the sandbox. It also maps a socket path into the sandbox. socat intercepts the requests from curl and other applications and the app uses the whitelist in the <profile>.hosts key to decide if the connection can be permitted or not. An important limitation: client applications must support HTTP_PROXY + HTTPS_PROXY envars.

This exact mechanism, A + B, can be used for Adamant!

PonderCode is mostly done. I will continue this series in the future when I take a couple of days to iron out various bugs and streamline the codebase.

PonderCode Devlog 4

2026-09-06T03:09:45Z

The list of nice-to-have features is endless. I added a few of them today.

The first is price list support. The cost field of the OpenAI API is not reliable based on an analysis of the sessions I have captured. The token information is. So PonderCode now supports price lists with a DSL to compute pricing based on TOD¹ and prompt size. A dashboard shows history across providers, models and time.

The second is an improvement to the UX by allowing edits and deletions of prompts and events so that the context can be surgically pruned. I rejected branching as an option because it is too complex without also building some kind of graph-like UI so that you can see the flow of the conversation. Also, all sessions are persisted. You can load and read them at any time, or continue working on them using other models.

I had resigned myself to not supporting networking inside the sandbox except via fetch, but there might be a way out. It involves socat, sockets and proxy servers. I will have to do some experimentation.

Time-of-day ↩

PonderCode Devlog 3

2026-09-05T04:48:17Z

So PonderCode is almost feature-complete, and secure within reason. The profile system and UI were revamped. Profiles are now locked on start to avoid switching, unwittingly, to profiles with expansive permissions.

I added a feature that is probably useless but fun: jobs. I can now start multiple sessions with multiple models and switch between them. The jobs run on the server and the client only pulls the information and updates itself. The entire application is built with node and has but one dependency: smol-toml.

I had a lot of issues getting the client and server to play well. The app would persist sessions in a certain way and the client would show something else because each had a rigid way of looking at a turn as a set of prompts and responses. I had to invent a basic unidirectional tape mechanism where events are captured in one direction only and that tape then becomes the single source of truth for both the server and the client.

Here are some images from today's testing. This is MiMo testing the boundaries of the sandbox.

And this is a conversation with MiMo about the dispatch mechanism of my VM.

MuseSpark 1.3 Contributor

2026-09-04T14:19:57Z

MuseSpark Contributor 1.3 was released the day before yesterday. Even Gemini Flash 3.8 was released the exact same day. So many releases occur nowadays that it is hard to keep track of them all.

I tried the new MuseSpark on OpenCode Go and it is a substantial improvement over its sibling: the 1.2 release. It is noticeably sharper in its reasoning. It is disappointing that the model continues to hide the CoT reasoning traces and returns summaries instead.¹ I still think DeepSeek V4 Flash is the smarter of the two, but the gap seems to have narrowed significantly. The pricing is the same as before:

Type	Price
Cached Read	$0.002/M
Input	$0.10/M
Output	$0.20/M

And OpenCode Go provides the same 6x factor, turning a $10 subscription into $60 of usage.

Chain-of-thought. Both DeepSeek and Qwen are far more open about this. ↩

PonderCode Devlog 2

2026-09-04T03:25:23Z

I spent a lot of time today polishing the UI/UX. Vertical space is a luxury even on large monitors. You do not want the chat box blocking the bottom 10% of the screen when you are not using it. The page header must go as well.

Network access is currently only available via the fetch tool call. So, no curl, npm or uv. Next on the list is a review of the sandboxing subsystem. Right now, it uses the dumb strategy of locking everything down and mapping paths from the profile. It does not offer much control beyond that.

I also need to revisit the tool and profile subsystems as I am considering adding a proper tool tool which makes the top level vcs tool an aberration. It should preferably be part of the tool interface:

tool uv
tool npm
tool vcs

The following is under consideration:

tool uv add <package>
tool uv remove <package>
tool npm add <package>
tool npm remove <package>
tool vcs ...

Which means vcs can be dropped from the top level.

As of this moment, PonderCode is a fantastic brainstorming tool. It can talk to any model over the OpenAI API. The following is a conversation with Ling 3.0 from OpenRouter:

And here, I am building Sudoku using MiniMax M3 from OpenRouter:

PonderCode

2026-09-03T13:08:53Z

I have talked about sandboxing, Bubblewrap, OpenCode Go and pi in previous logs. I finally decided to take the plunge and develop my own coding harness. My normal workflow revolves around spec-based development and a lot of pondering before I get the LLM to make changes. So I have decided to call the harness PonderCode.

The initial feature set:

Sandboxing is nonnegotiable and must be enabled by default
Tools: read/write/replace/list/move/search/fetch/exec/vcs
A profile system where a profile specifies the tools available, the whitelist of hosts for fetch, and the folders and files that must be mapped into the sandbox in ro/rw mode
KV caching for llama.cpp
Session continuations: start a session with one model and continue it with another

I store provider and model information, as well as profiles in a TOML file. The harness executes the profile against the current directory.

I got an initial version working today.

Here, you can see the KV prefix caching mechanism working with llama.cpp. pp is 29K t/s with a Q4 quant of Gemma 4 12B running on my 9070 XT!

I also hit some other important milestones today:

fetch can only connect to domain name and ip:port combinations in the profile whitelist.
exec is only allowed inside a Bubblewrap sandbox where no network is available.

While there is some overlap between Adamant and PonderCode, they are two completely different projects:

Adamant is planned as a general wrapper around Bubblewrap.
PonderCode is a harness that produces LLM-specific sandboxing.

OpenCode Go Stats

2026-09-01T03:41:17Z

After two weeks of 12-14h of coding every day on average, I have used only 18% of the monthly limit. DeepSeek, MiMo and MuseSpark are doing a lot of work for pennies on the dollar.

Adamant

2026-08-31T01:37:19Z

Bubblewrap is great if verbose. Some automation is called for. Enter Adamant: A profile-based sandbox runner built on top of Bubblewrap.

The idea is ridiculously simple: use ldd (or even readelf or strace) to determine which libraries and files an executable requires and store the list somewhere. A profile system makes sense. Something like

# ~/.config/adamant/profiles/shell.toml
network = "none"

ro = [
    "/usr/lib/ld-linux-x86-64.so.2",
    "/usr/lib/libc.so.6",
    "/usr/lib/libgcc_s.so.1",
    "/usr/lib/libm.so.6",
    "/usr/lib/libpcre2-32.so.0",
    "/usr/lib/libpcre2-32.so.0.15.0",
    "/usr/lib/libpcre2-8.so.0",
    "/usr/lib/libpcre2-8.so.0.15.0",
    "/lib64/ld-linux-x86-64.so.2",
    "/usr/lib/libncursesw.so.6",
    "/usr/lib/libncursesw.so.6.6",
    "/usr/lib/libreadline.so.8",
    "/usr/lib/libreadline.so.8.3",
    "/usr/bin/bash",
    "/usr/bin/ls",
    "/usr/lib/libcap.so.2",
    "/usr/lib/libcap.so.2.78",
]

which can be produced using

adamant prepare --profile shell bash
adamant prepare --profile shell ls

and run like so:

adamant run --profile shell bash

This command uses the list to produce the bwrap --clearenv ... machinery we saw earlier.

Problems:

Network is all or nothing
node works. npm doesn't, as it is a shell script and not an ELF executable
ldd and readelf results do not tally. Is readelf even necessary?

Investigation is required.

Bubblewrap

2026-08-30T04:01:42Z

So, Bubblewrap.

bwrap --clearenv --unshare-all --die-with-parent \
      --tmpfs / \
      --ro-bind /usr /usr \
      --ro-bind /lib64 /lib64 \
      sh

drops you into a shell where you can run some utilities but not much else because the entire root partition has been mounted on tmpfs and then only two specific trees, /usr and /lib64, have been mapped into the sandbox.

--clearenv clears all environment variables.

--unshare-all unmaps 6 namespaces: user ipc pid net uts cgroup

Bubblewrap creates the mount namespace from scratch. --tmpfs and --ro-bind create or map parts of the file system into the sandbox.

If you want to see the minimal mapping required to get sh working, you do this: ldd /usr/bin/sh, and map all the libraries it outputs. To cut a long story short, this is the minimal sandbox needed to execute sh:

bwrap --clearenv --unshare-all --die-with-parent \
      --tmpfs / \
      --ro-bind /usr/lib/libreadline.so.8 /usr/lib/libreadline.so.8 \
      --ro-bind /usr/lib/libc.so.6 /usr/lib/libc.so.6 \
      --ro-bind /lib64/ld-linux-x86-64.so.2 /lib64/ld-linux-x86-64.so.2 \
      --ro-bind /usr/lib/libncursesw.so.6 /usr/lib/libncursesw.so.6 \
      --ro-bind /usr/bin/sh /usr/bin/sh \
      sh

Add these flags if you want to poke around:

--ro-bind /usr/lib/libcap.so.2 /usr/lib/libcap.so.2 \
--ro-bind /usr/bin/ls /usr/bin/ls \

Sandbox

2026-08-29T13:10:44Z

Running software on your machine has always carried with it some risk: viruses, trojans, malware, ransomware and whatnot coming along for the ride. Recently, there have been supply chain attacks across the spectrum: popular projects on GitHub, name- and typo-squatting or account takeovers on npm, the Arch Linux AUR etc. Though problematic, there are mitigations that you can employ against each of these risks.

I have been using coding harnesses for a while now, and doing so directly on the dev machine. And I am not alone. This sounds insane, given the risks cited above, in this age of VMs and containers. But convenience outweighs the risk of catastrophe every single time.

Earlier this year, when OpenClaw was everywhere, I briefly considered agents and even built my own runtime called Sēvaka: a secure execution runtime for autonomous AI workers. It had a lot of features including taints: the ability to tag the source of data and prevent it from crossing specified boundaries. But I lost interest in it after the proof of concept was done.

More recently, though, I decided I wanted something far more mundane: the ability to run pi in a sandboxed environment. I didn't want the complexity of Docker or Podman. So I went searching. And discovered Bubblewrap.

AMD ROCm 10

2026-08-28T18:14:31Z

AMD has bumped the version of its ROCm SDK from 7.2.4 to 10.0. I have a 9070 XT. I previously had a 6700 XT. The Vulkan and ROCm interfaces behave differently enough to be a constant irritant.

Vulkan is easy to use with llama.cpp. Other LLM tooling often requires ROCm.

pp is higher in ROCm than Vulkan. The reverse is the case with tg.¹

Performance of llama.cpp with Vulkan #10879 ↩

Mogra OCR

2026-08-27T22:28:23Z

I spent the last couple of weeks trying to build an OCR engine for Devanagari and Latin texts. I call it Mogra. LLMs are fine, and Google Cloud Vision works reasonably well on old Sanskrit books. But we need something like Tesseract: OSS that runs easily on a toaster.

After several false starts with C(R)NN+CTC+BiLSTM, I scrapped the design in favor of a template-matching system. It works as follows:

You add a book to the project and extract the images
The app provides a UI that lets you tag character boxes with the actual character. The mapping is stored
The app uses this mapping to rapidly perform a sliding-window match across the entire book

I ran a test with Stephen Leacock's Sunshine Sketches of a Little Town. The best Tesseract timing was 39s for those 296 pages using:

export OMP_NUM_THREADS=8
mkdir -p ./output
parallel -j 8 tesseract -l eng {} ./output/{/.} ::: ./input/*.png

Mogra's mogra-mt¹ backend does it in 6s. And the output is comparable to Tesseract.

With more work, beating Tesseract is feasible. The drawback is that you need to spend 15-30 min doing the mapping manually for each book.

The project is presently on the back burner as I am busy with Bhāṣikā and some other stuff. But I will revisit it soon enough.

mt = metal-type ↩

Coding Style

2026-08-24T15:19:33Z

I have developed a very specific way of writing code over time. While extending an application causes a collapse in discipline in order to get things done, I do try to stick to it where feasible. With the rise of coding LLMs, this task has become a lot easier. I can write what I want and then have it review the codebase and fix it according to my guidelines.

While my guidelines are often project-specific, the following is a good baseline to follow and gives me maintainable code.

Basic Code Guidelines

Use SRP/DRY
Functions + immutable data structures > objects with methods
Fail fast: no defensive programming, no backward compatibility, no provisions for migrations
Loose coupling: touching one part of the system should not have a cascading effect across the entire system
No global mutable state. Thread a State/Environment object through as the first parameter of every function that needs it.
No stringly-typed code. When used doing hydration/serialization, verify that the strings do not leak beyond function boundaries.
In client/server architecture, both client and server must share a single contract. JSON/XML payload must be lifted into typed data structures before they can be used.
No magic numbers or strings. Lift into constants that are defined in one place and used everywhere.
Unless a branch exits early (if not x then return y), every if must have an else. Every switch must have a default. Impossible paths must throw a NotPossible Assertion, thereby crashing the program.
Error should only be caught if the function knows what to do with it.

Naming

Kind	Convention	Example
Functions	`snake_case`, noun-first	`user_create()`, `mail_send()`
Dataclasses	`PascalCase`	`User`, `VerificationCode`
Modules	`snake_case`	`email_service.py`
Constants / enums	`UPPER_SNAKE_CASE`	`MAX_RETRY_COUNT`

Exception Taxonomy

Kind	Meaning	Handling
Fault	Unrecoverable (connection loss, HTTP 500)	Expose via banner/terminal in the UI. Never retried silently.
Error	Expected in normal business operation (`FileNotFound`, `InvalidCoupon`, `PasswordTooShort`)	Handle explicitly, and report to the user in the normal execution flow.
Assertion	API/Function contract breached	Expose via banner/terminal in the UI. Application crashes hard. Never swallowed.

Error vs Assertion is a judgment call. A 403/404 can mean a genuine dev mistake (stale URL) or hostile interference (tampered payload/route). This must be resolved depending on the application environment: dev vs production.

Exceptions must never be swallowed silently in any of the three cases.

I wrap the above guidelines in a simple prompt:

Do a comprehensive code review of `@src/` and write it to `@docs/<YYYYMMDD[A-Z]>_CODE_REVIEW.md`.

Extract the architecture of the application from the code and write it to `@docs/<YYYYMMDD[A-Z]>_ARCHITECTURE.md`. The elements I am interested in include:

- An intro: what the application does
- Application layout
- The expected shape of the input data, and the output
- Etc

This is more than enough to guide most LLMs to do the right thing.

MuseSpark 1.2 Contributor

2026-08-22T13:29:03Z

With DeepSeek now billing separately for peak and off-peak usage, and MiMo being somewhat dumb, I need something that can fill the gap. And MuseSpark 1.2 seems to be it.

A surprise launch from Meta after the Llama 4 debacle.¹ MuseSpark is pretty smart. Not as smart as DeepSeek V4 Flash, but smart nevertheless.

It has Vision capabilities like MiMo does, though it will try to use Tesseract or some such locally if you provide too many files.

I registered on the Meta AI website last week in order to try it. But it wanted my selfie before it would let me in. So I declined the offer. Thankfully, it is available via OpenCode with no such restrictions.

The Contributor version has incredible pricing because Meta, by its own admission, wants to train on your data:

Type	Price
Cached Read	$0.002/M
Input	$0.10/M
Output	$0.20/M

It could be a great translation tool, I feel. I tried translating a Sanskrit story. Here are the original, the MuseSpark version, and the Gemini Pro 3.1 version side-by-side:

O: चीनांशुकम्
MS: China Silk
MS lit: China-cloth
GP: Chinese Silk
GP lit: Chinese silk

O: द्वित्रसहस्रवर्षेभ्यः पूर्वं चीनादेशे कश्चन राजा आसीत्।
MS: Two to three thousand years ago, there was a king in China.
MS lit: Two-three-thousand-years before in China a certain king was.
GP: Two to three thousand years ago, there was a king in China.
GP lit: Before two-three thousand years, in China country some king was.

O: तस्य पत्न्याः नाम चीलिंग्षी इति।
MS: His wife was named Xi Ling Shi.
MS lit: Of him wife's name Xi Ling Shi thus.
GP: His wife's name was Chilingshi.
GP lit: Of his wife the name 'Chilingshi' thus.

O: सा परमसुन्दरी।
MS: She was exceedingly beautiful.
MS lit: She very-beautiful.
GP: She was exceptionally beautiful.
GP lit: She supremely beautiful.

O: विवाहसमये तस्याः वयः चतुर्दश वर्षाणि।
MS: At the time of their marriage she was fourteen years old.
MS lit: At marriage-time of her age fourteen years.
GP: At the time of their marriage, she was fourteen years old.
GP lit: At marriage time her age fourteen years.

Pretty close in my opinion. And Gemini Pro has been my go-to for Sanskrit translations for the past couple of years.

Rumors of benchmaxxing ↩

MiMo 2.5

2026-08-19T19:38:17Z

With the massive price bump by DeepSeek, you now have to plan your work around its off-peak hours if you want your OpenCode Go subscription to last. So I have been looking for alternatives and MiMo 2.5 is a good one. It is not very smart, but you can get it to follow your instructions, mostly. Every few hours, you can get DeepSeek V4 Flash to jump in, do a code review and then clean up the codebase for you.

MiMo's vision capabilities surprised me with the Mogra OCR project. It was able to load images, detect features and work based on such detection. DeepSeek is missing this feature.

I estimate cache expiry is nearly an hour. So you get a lot of time to think as you code.