1. Edit XML in a text editor

2. Open a terminal

3. Run a Docker build that takes 15–20 minutes

4. Open a browser and manually navigate to the right chapter

5. Realize one equation is slightly wrong

6. Go back to step 1

No live preview. No integrated editor. No way to share a draft without giving someone SSH access. Just a loop of edit → build → check → repeat.

I spent the last few months building Proofdesk to fix this — a full-stack browser workspace where professors can write, build, preview, and publish math textbooks without ever leaving the browser.

But honestly? The interesting part isn't the React frontend or the Node backend. The interesting part is the build pipeline I had to engineer to make any of this work.

What is PreTeXt and why does anyone use it?

PreTeXt is an XML-based markup language for writing math textbooks. Instead of writing raw LaTeX, you write structured XML that describes the content — theorems, definitions, proofs, figures — and the toolchain handles rendering.

The output is genuinely beautiful: properly typeset math, interactive 3D visualizations, accessible HTML, and a consistent structure that works across print and web. Georgia Tech's Introduction to Linear Algebra textbook (used by thousands of students) is written in PreTeXt.

The catch: the toolchain is a time capsule from 2014.

The dependency hell I walked into

The PreTeXt build system was written for a very specific era. Running it in 2026 means dealing with:

• Python 2 — unichr(), print statements, Popen with universal_newlines=True returning bytes instead of strings

• Ruby 2-era gems — specifically compass, which is incompatible with Ruby 3.2+

• Inkscape 0.9x CLI syntax — the --file= and --export-plain-svg= flags were removed in Inkscape 1.x

• CoffeeScript 1.12.7 — not compatible with CoffeeScript 2.x

• SCons with custom builders — a build system almost nobody uses anymore, with undocumented suffix declaration requirements that break cache-busting if you get them wrong

None of this works on a modern Ubuntu system without patching. And I couldn't just fork the PreTeXt repo and fix it — professors need to pull upstream changes from the original repo without losing my fixes.

So I wrote a 720-line Docker build script that patches everything at build time, without permanently modifying the source.

How the build script works

The approach: clone the upstream repo cleanly, apply patches in memory during the build, build the textbook, discard the patches. The source repo stays unmodified and pullable.

Here's what the script patches and why:

Python 2 → Python 3

# unichr() was removed in Python 3
sed -i 's/unichr(/chr(/g' pretex/aglfn.py

# Inkscape 1.x dropped the old CLI flags entirely
# We rewrite the inkscape_script() method in-place
python3 - <<'EOF'
import re

with open('pretex/processtex.py', 'r') as f:
    src = f.read()

new_method = '''
def inkscape_script(self, pdf_file, svg_file):
    return [
        'inkscape',
        '--actions=export-type:svg;export-plain-svg;export-do',
        f'--export-filename={svg_file}',
        pdf_file
    ]
'''

src = re.sub(
    r'def inkscape_script.*?(?=\ndef |\nclass )',
    new_method,
    src,
    flags=re.DOTALL
)

with open('pretex/processtex.py', 'w') as f:
    f.write(src)
EOF

Ruby 3.2 compatibility

compass uses File.exists? which was removed in Ruby 3.2 (it was deprecated since Ruby 2.1). Rather than fix compass, the script falls back to sass-embedded:

if gem list compass -i > /dev/null 2>&1; then
    compass compile
else
    # Fall back to sass-embedded — same output, modern Ruby compatible
    sass --no-source-map mathbook-assets/scss/mathbook.scss \
         mathbook-assets/css/mathbook.css
fi

SCons builder suffix declarations

This one took me an embarrassing amount of time. The custom CatJS and CatCSS SCons builders were missing explicit suffix='.js' and suffix='.css' declarations. Without them, SCons generates extensionless intermediate files. The version_filter cache-busting logic in demos/SConscript then can't find those files and aborts the build.

# Before (broken in Python 3 SCons)
def CatJS(env, target, sources):
    ...

# After (works)
def CatJS(env, target, sources):
    ...
env['BUILDERS']['CatJS'] = Builder(action=CatJS, suffix='.js')

The math rendering pipeline

This is the part that makes Proofdesk worth building. Every equation in the textbook goes through this pipeline:

PreTeXt XML
    ↓ xsltproc (XSL transforms)
HTML with <script type="text/x-latex-inline">Ax = b</script> placeholders
    ↓ pretex.py (extracts all LaTeX expressions)
Batch .tex files
    ↓ pdflatex
One PDF per equation
    ↓ fontforge (extracts font metrics + ToUnicode tables)
Font metric data
    ↓ Inkscape 1.x (--actions=export-type:svg;export-do)
Equation SVG files
    ↓ pretex.py (inlines SVGs back into HTML)
Final HTML with <svg xmlns="...">...</svg> embedded

The result: every equation is a crisp, perfectly-kerned SVG that renders identically at any zoom level, with no JavaScript runtime dependency. No MathJax loading delay. No font fallback artifacts. Just math that looks exactly like a printed textbook.

The fontforge step is what makes it possible. It extracts the exact character widths and kerning pairs from the Charter typeface so the SVG layout matches what pdflatex produced. This is the same approach academic publishers use for high-quality math rendering.

Docker-in-Docker orchestration

The Proofdesk backend runs on EC2 and needs to spawn PreTeXt build containers on demand for each user session. The approach: mount the Docker socket into the backend container and use the Docker SDK for Node to create sibling containers.

const docker = new Docker({ socketPath: '/var/run/docker.sock' });

async function spawnBuildContainer(sessionId, repoPath, outputPath) {
  const container = await docker.createContainer({
    Image: 'proofdesk-pretext-builder',
    Cmd: ['build', '/repo', '/output'],
    HostConfig: {
      Binds: [
        `${repoPath}:/repo:ro`,
        `${outputPath}:/output:rw`,
      ],
      Memory: 1.5 * 1024 * 1024 * 1024, // 1.5GB cap per build
      AutoRemove: true,
    },
  });

  // Stream stdout/stderr back to the browser over WebSocket
  const stream = await container.attach({
    stream: true, stdout: true, stderr: true
  });

  stream.on('data', (chunk) => {
    wss.clients.forEach(client => {
      if (client.sessionId === sessionId) {
        client.send(JSON.stringify({ type: 'build-log', data: chunk.toString() }));
      }
    });
  });

  await container.start();
  return container;
}

The 1.5GB memory cap per container is critical on a t3.small with 2GB total RAM. The pretex equation renderer spawns multiple parallel pdflatex workers — without a cap, a single build OOM-kills the entire instance.

Real terminal in the browser

Professors sometimes need to run SCons commands directly, inspect intermediate build artifacts, or debug a broken equation. So Proofdesk ships a real terminal — same TTY behavior as SSH, not a fake shell.

The stack: node-pty on the backend spawns a real pseudoterminal. The output streams over WebSocket to xterm.js on the frontend.

// Backend — spawn a real PTY
const pty = require('node-pty');

const shell = pty.spawn('bash', [], {
  name: 'xterm-color',
  cols: 80,
  rows: 24,
  cwd: sessionWorkDir,
  env: process.env,
});

shell.on('data', (data) => {
  ws.send(JSON.stringify({ type: 'terminal', data }));
});

ws.on('message', (msg) => {
  const { type, data } = JSON.parse(msg);
  if (type === 'terminal-input') shell.write(data);
  if (type === 'terminal-resize') shell.resize(data.cols, data.rows);
});

The resize handling matters more than you'd think. Without it, tools like vim and less render incorrectly when the browser window changes size.

Shareable preview links

One of the most useful features for professors: share a draft chapter with a student or co-author without giving them GitHub access.

// POST /build/share/:sessionId
router.post('/share/:sessionId', async (req, res) => {
  const token = crypto.randomBytes(16).toString('hex'); // 32-char hex
  const expiresAt = Date.now() + 7 * 24 * 60 * 60 * 1000; // 7 days

  await redis.set(
    `share:${token}`,
    JSON.stringify({ sessionId: req.params.sessionId, expiresAt }),
    'EX', 7 * 24 * 60 * 60
  );

  res.json({ url: `\({BASE_URL}/shared/\){token}` });
});

// GET /shared/:token/* — no auth required
router.get('/shared/:token/*', async (req, res) => {
  const entry = await redis.get(`share:${req.params.token}`);
  if (!entry) return res.status(404).send('Link expired or not found');

  const { sessionId, expiresAt } = JSON.parse(entry);
  if (Date.now() > expiresAt) return res.status(410).send('Link expired');

  const filePath = path.join(outputDir, sessionId, req.params[0] || 'overview.html');
  res.sendFile(filePath);
});

No S3, no CDN — the built output lives on the EC2 filesystem and gets served directly. Good enough for academic use at this scale.

What broke in production (and what I'm still debugging)

I'll be honest: the deployed site at proofdesk.duckdns.org has a text overlap bug that doesn't reproduce locally. My current theory is that the Charter web fonts are being served by Nginx without the correct font/woff2 MIME type, causing the browser to silently reject them and fall back to a system serif with different letter-spacing.

If you've hit this before — Nginx serving fonts from a Docker volume with wrong MIME types — I'd genuinely love to hear how you fixed it.

What's next

• Multi-textbook support — paste any PreTeXt GitHub URL and get a full workspace instantly

• Incremental builds — only rebuild changed chapters, cutting build time from 15 min to under 2 min

• Student mode — read-only workspace with a purpose-limited AI tutor scoped to the textbook content

• CRDT collaboration — operational-transform or CRDT-based simultaneous editing for co-authors

• LMS integration — Canvas/Blackboard SSO for institutional deployment

The repo

Proofdesk is fully open source: github.com/harsharajkumar/proofdesk

If you write or maintain a PreTeXt textbook, I'd genuinely love feedback on what's missing from your workflow. And if you're a developer who's dealt with legacy Python 2 / Ruby 2 / Inkscape 0.9x build systems in Docker — you have my respect.

I'm Harsha Raj Kumar, MS CS at Vanderbilt University, Research Assistant at VU-BEAM Lab. Building AI tools and infrastructure systems. Find me at github.com/harsharajkumar.