Forem: TeX64

I Stopped Retyping Math Equations From Lecture Slides — Here's What I Use Now

TeX64 — Thu, 02 Apr 2026 00:38:22 +0000

If you've ever taken a graduate-level math, physics, or engineering course, you know the pain. The professor puts up a slide with a beautiful Hamiltonian or a triple integral with a Jacobian, and your first thought is: I'm going to need this in my thesis.

Your second thought: I'm going to have to retype this entire thing in LaTeX, aren't I.

And then you spend 20 minutes on it. And then you get a compile error. And then you spend 10 more minutes figuring out you had an extra closing brace somewhere in the middle of the subscript.

I did this for two years during my master's degree before I found a better way.

The Problem With the Existing Workflow

There are actually good tools for converting images of equations to LaTeX. Mathpix Snip is the most well-known, and the accuracy is genuinely impressive. But here's what the workflow actually looks like in practice:

Take a screenshot of the slide
Open the Mathpix app (or switch to the Mathpix tab)
Paste the screenshot
Wait for the conversion
Copy the LaTeX output
Switch back to your editor
Paste into your .tex file
Run the compiler
Fix errors if any

That's nine steps. For every single equation. During a lecture where you're also trying to understand the material and take notes.

I also tried pix2tex, which is an open-source Python-based OCR tool that runs locally. The math: it works reasonably well once you've got it set up. The problem: getting it set up on Apple Silicon took me an hour of dealing with PyTorch version conflicts. And even after that, the workflow is still "separate tool → copy → paste → switch back to editor."

Google Gemini can do it too if you paste an image and ask nicely. Also a context switch.

The core issue isn't any of these tools specifically. It's that the OCR lives outside the editor. You're constantly breaking your flow to go get the LaTeX and bring it back.

What TeX64 Does Differently

TeX64 is a local-first LaTeX editor for macOS (https://tex64.com). I started using it primarily because I was tired of Overleaf's free-tier compile limits during my thesis crunch, but I quickly discovered it had built-in equation OCR.

The workflow is:

Take a screenshot (Cmd+Shift+4 on macOS)
Paste it into TeX64 (Cmd+V)
LaTeX code appears

That's it. Three steps. You never leave the editor.

Real Examples From My Coursework

Example 1: Partition Function (Statistical Mechanics)

The slide showed: Z = Σ_n exp(-β E_n)

TeX64 OCR output:

Z = \sum_{n} e^{-\beta E_n}

Exact. Ready to paste.

Example 2: Fourier Transform Definition

\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) \, e^{-2\pi i x \xi} \, dx

Including the \, spacing before dx. That's a nice detail I would have forgotten.

Example 3: Quantum State Vector Expansion

|\psi\rangle = \sum_{n=0}^{\infty} c_n |n\rangle, \quad c_n = \langle n | \psi \rangle

The bra-ket notation came out correctly — \langle, \rangle, the whole thing.

When OCR Gets It Wrong

It's not 100% perfect. Complex multi-line expressions sometimes have minor issues.

This is where TeX64's AI assistant, Axiom, becomes useful. When I get a compile error after an OCR paste, I can ask Axiom to look at the log. It reads the actual compile output and shows me a diff: "line 47, change this to that." One click to apply.

Everything — OCR, editing, error fixing — stays in one app.

Honest Limitations

macOS only. Apple Silicon and Intel Mac only.
You still need MacTeX or TeX Live. TeX64 is the editor, not the TeX distribution.
OCR is for math, not text. It won't transcribe surrounding prose from a slide.
Handwriting accuracy drops a bit. Clean PDF slides work much better than photographed handwriting.
Free tier has limits. Heavy OCR usage requires a paid plan.

Why This Actually Matters

The difference between "screenshot → paste → done" and "screenshot → open app → paste → copy → switch app → paste → compile" is not just time. The first stays in flow. The second breaks it.

If you're writing LaTeX on a Mac and frequently pulling equations from slides or PDFs, it's worth trying TeX64 just for this feature.

https://tex64.com

I Was Told to Write My Thesis in LaTeX. Here's How I Actually Got Started.

TeX64 — Wed, 01 Apr 2026 01:11:16 +0000

My advisor’s email said: “Please submit your thesis in LaTeX format.”

I had two reactions: first, mild panic — I’d never written anything in LaTeX. Second, the overconfident thought that I could figure it out over a long weekend.

Spoiler: the weekend came and went. I was still staring at a wall of compile errors I couldn’t parse.

Three Attempts, Three Failures

Attempt 1: MacTeX + TeXShop

I downloaded MacTeX (the full 5GB installation — took forever), opened the bundled TeXShop editor, pasted in a sample document, hit compile, and got this:

! LaTeX Error: File `amsmath.sty' not found.

Spent an hour searching Stack Overflow. The suggested fix was to run tlmgr install amsmath in the terminal. Ran it. Got a different error. Gave up.

Attempt 2: VSCode + LaTeX Workshop

People on Reddit swore by this setup. So I installed VSCode, installed the LaTeX Workshop extension, copied a settings.json snippet from a blog post, and managed to compile a basic document. Then I tried to write Japanese text in it. Characters came out garbled. I spent ninety minutes debugging the encoding issue before abandoning this path too.

Attempt 3: Overleaf

Fine. I’ll use the browser-based one. No installation required, real-time preview, beautiful. Worked great right up until my thesis hit 80 pages and the free tier started timing out on compiles. The paid plan was $19/month. I wasn’t ready to commit.

What Finally Worked: TeX64

A classmate mentioned TeX64, a macOS-native LaTeX editor. I was skeptical — I’d already wasted hours on three other tools. But I tried it, and something clicked.

The First Thing I Noticed: It Tells You What’s Wrong

When I opened TeX64 for the first time, the app ran a quick diagnostic of my environment. Instead of a cryptic error, I saw something like:

⚠ latexmk not found. It looks like MacTeX isn’t installed. You can download it here: [link]

This might sound like a small thing. But after hours of Googling vague error messages, having software just tell me what the problem is felt almost revolutionary. I installed MacTeX by following the link, restarted TeX64, and it worked.

TeX64 runs entirely on your Mac — Apple Silicon and Intel both — with all compilation happening locally. Once MacTeX is installed, you don’t need an internet connection to write or compile.

Axiom: An AI That Actually Understands LaTeX Errors

Every LaTeX beginner eventually hits this wall: the compile fails with an error message that makes no sense to a human.

! Misplaced alignment tab character &.
l.34  & 2x + 3y

I’d stare at this for ten minutes, cross-reference it with a LaTeX cheat sheet, wonder if I was missing a package, and eventually just delete whatever I’d written and start over.

TeX64 has a built-in AI assistant called Axiom. When a compile fails, Axiom reads the error log alongside your .tex files and gives you a plain-English explanation:

"The & character on line 34 is being used outside an alignment environment like align or tabular. Try wrapping your equations in \begin{align} ... \end{align}."

And then Axiom proposes a fix as a diff. You can review exactly what would change before applying it. It never silently modifies your files.

I went from "I’ll just delete this and rewrite it" to "okay, I understand what went wrong and I know how to fix it." That mindset shift mattered a lot in the early weeks.

Building Equations Without Memorizing Commands

One of the things that makes LaTeX intimidating for beginners is that math requires learning a whole new vocabulary of commands.

\int_{0}^{\infty} e^{-x^2} \, dx = \frac{\sqrt{\pi}}{2}

TeX64 has a visual math palette: a panel where you click symbols and see the equation rendered in real time. Click the integral sign, set the bounds, and TeX64 writes the LaTeX for you. The generated code is clean and editable. You can see what \int_{0}^{\infty} looks like as you build it, and gradually the syntax starts to make sense.

After two weeks of building equations with the palette and seeing the corresponding code, I found I could write many of them from memory without thinking.

SyncTeX: Click PDF, Jump to Source

SyncTeX syncs your PDF preview and source file bidirectionally. Click anywhere in the PDF, and your editor jumps to the corresponding line in the .tex file.

When your thesis is 100+ pages across multiple files, finding the source of any given paragraph becomes a real chore. With SyncTeX, I just click in the PDF wherever I want to edit, and I’m there instantly.

Honest Limitations

macOS only. TeX64 won’t run on Windows or Linux.

You still need MacTeX. TeX64 is an editor, not a LaTeX compiler. You’ll need MacTeX or TeX Live installed separately. TeX64 walks you through this if it’s missing.

No real-time collaboration. Overleaf is still the better choice for simultaneous co-authoring.

AI features have usage limits on the free tier. Basic editing, compilation, and SyncTeX are free with no account required. Heavy use of Axiom or OCR requires a paid plan.

How to Get Started

Go to tex64.com and download the app.
Open TeX64 — it will detect if MacTeX is missing and guide you through installing it.
Create a new document and try compiling the template.
If anything goes wrong, ask Axiom.

TeX64 shortens the path from "I don’t know where to start" to "I’m actually writing LaTeX." For Mac users, that’s worth a lot.

Check it out at tex64.com.

I Used to Dread Writing Matrices in LaTeX. Here's What Changed.

TeX64 — Tue, 31 Mar 2026 00:33:52 +0000

There's a specific kind of frustration that only LaTeX users understand. You're trying to write a 5×5 matrix at midnight before a deadline, and your compile output says:

! Extra alignment tab has been changed to \cr.

You stare at the error. You count the ampersands. You count them again. You find the row where you put four & symbols instead of three. You fix it. You recompile. Now a different row is wrong.

If you've been there, this article is for you.

The Hidden Cost of LaTeX Matrix Syntax

Writing matrices in LaTeX requires precise bookkeeping. For every row, you need exactly (n-1) ampersands for an n-column matrix, a \\\\ at the end of every row except the last, and the correct \\begin{pmatrix} variant depending on whether you want round brackets, square brackets, or none.

None of this is difficult conceptually. But it's deeply mechanical, and mechanical tasks done under cognitive load produce mistakes. When you're thinking about linear algebra — about what the matrix means — you don't want to be counting ampersands.

I've written LaTeX for about six years across undergrad, grad school, and work. Matrices have always been the part I dreaded most. I tried a few different approaches:

Online matrix generators — You fill in rows and columns on a website and it spits out LaTeX. Works fine, but you're constantly context-switching between browser and editor. And they're useless offline.

Snippets and templates — I built a library of snippet templates in my editor: 2×2, 3×3, and so on. Helped for common sizes but fell apart for anything irregular.

Just memorizing the syntax — The classic approach. Still fails under pressure.

Finding TeX64

A few months ago I switched my main LaTeX workflow to TeX64, a macOS-native LaTeX editor. I was originally drawn to it for its AI error-fixing, but the feature I ended up using most for daily work was something simpler: the visual math input palette.

The palette lets you build equations by clicking symbols and templates. For matrices, you select the matrix template, specify the dimensions, and a correctly-structured skeleton is generated immediately. Each cell is a tab-stop you fill in order.

The crucial part: it renders in real time. You see the actual typeset output as you fill in the cells, not the raw LaTeX. This completely changes the feedback loop. Instead of write → compile → read error → count ampersands → fix → recompile, you get an immediate visual signal. You can see if a cell is wrong before you've even finished typing the row.

Here's what a session looks like now: I click the 4×4 matrix template, tab through the 16 cells filling in my coefficients, glance at the preview to confirm it looks right, and move on. The whole thing takes maybe 30 seconds. The generated LaTeX is clean and standard — I can edit it by hand afterward if I need to.

Where the AI Comes In

TeX64 has a built-in AI assistant called Axiom. It reads your entire project — all your .tex files, your compile log, your BibTeX — and responds to natural language requests.

For matrices specifically, Axiom is useful for a few different things:

Generating complex structures from description. If I need a block matrix or a tridiagonal matrix, describing it in English is faster than building it manually. "Write a block matrix with A in the top left, B in the top right, and zeros everywhere else" — Axiom produces the LaTeX, presents it as a diff, and I apply it with one click.

Fixing errors. If a matrix-related compile error slips through, I paste the log into Axiom and ask it to fix the issue. It identifies the line, explains what's wrong, and shows the corrected code as a diff. Never modifies files silently — always shows you what will change before applying.

Converting from images. TeX64 has equation OCR built in. If I have a matrix in a PDF paper I'm citing, or a photo of handwritten notes, I can paste the image and get editable LaTeX back. This is especially useful when reusing equations from older papers rather than retyping everything from scratch.

A Concrete Example

Last week I was writing a section on Markov chains and needed a 5×5 transition probability matrix. Before TeX64, this would have taken me 10+ minutes between typing, error-hunting, and formatting.

Here's what happened instead:

Axiom: "Write a 5×5 stochastic matrix where each row sums to 1, use variable names p_{ij}"
Axiom produced the skeleton with proper subscript notation
I replaced the placeholder values with my actual probabilities using the visual editor
Total time: about 4 minutes, zero compile errors

Not dramatic, but multiply that by the 30-40 matrices that appear in a typical research paper, and the time savings add up significantly.

Honest Limitations

I want to be straightforward about what TeX64 isn't:

macOS only. If you're on Windows or Linux, this isn't for you. TeX64 runs on Apple Silicon and Intel Macs only.

Requires MacTeX or TeX Live. TeX64 is an editor, not a full LaTeX distribution. You still need a LaTeX installation for compilation. First-time setup takes about 20 minutes, and TeX64's environment diagnostics will tell you exactly what's missing. But it's a real prerequisite.

Heavy AI/OCR usage requires a paid plan. There's a free tier, and you don't need an account to start. But if you're doing a lot of AI-assisted editing or OCR conversions, you'll eventually hit the free limits.

Real-time collaboration isn't the focus. If you're co-writing with three coauthors on a shared document, Overleaf is better for that use case. TeX64 is optimized for solo or small-team work where you want local compilation and the full power of a native Mac app.

The Part That Surprised Me

I expected the visual matrix editor to feel like a crutch — something I'd use when I was lazy, then abandon when I got back to "real" LaTeX work. That didn't happen.

The reason is that the output is regular LaTeX. There's no abstraction layer, no proprietary format. The visual editor is just a fast way to generate standard code. Once it's in your file, it's identical to what you'd write by hand. You can edit it by hand. Other tools can read it. It compiles with any LaTeX engine.

That's the design choice that makes it actually useful rather than just a toy: it accelerates the mechanical parts without creating lock-in.

Try It

If you write LaTeX on a Mac and matrices are a regular part of your work — papers, theses, homework sets, anything — it's worth trying. The free tier is enough to get a real sense of the workflow.

tex64.com

I turned a notebook full of handwritten math into a LaTeX paper — here's how

TeX64 — Mon, 30 Mar 2026 01:14:43 +0000

Here's a scenario I'll bet some of you recognize: you've been working through a problem by hand for weeks. Your notebook is full of half-finished derivations, scribbled integrals, matrices with question marks next to them. And now you need to turn that mess into a proper LaTeX document.

I had exactly this situation last winter. Forty-odd pages of handwritten notes from a research project, and a paper deadline looming. I knew I couldn't retype everything — especially not the equations. There had to be a better way.

The copy-paste treadmill

The first tool I tried was Mathpix Snip. It's well-known in academic circles for a reason: the OCR accuracy on mathematical notation is genuinely impressive. You screenshot a handwritten equation, and you get clean LaTeX back within seconds.

The problem wasn't the accuracy. The problem was the workflow.

Every single equation involved:

Take a screenshot or photo
Switch to the OCR tool
Wait for conversion
Copy the LaTeX
Switch back to my editor
Paste and adjust

For a single equation, that's fine. For forty pages? It's death by a thousand context switches. By day two I was dreading opening my notes.

Finding TeX64

I stumbled across TeX64 while searching for "latex editor mac ocr built in" or something like that. It's a macOS-only LaTeX editor — Apple Silicon and Intel both supported — and the key thing that caught my eye was that OCR is baked directly into the editor itself.

No separate app. No browser tab. No clipboard dance. You drop an image into the editor and the converted LaTeX appears in your document.

That sounded too good to be true, so I downloaded it (free tier, no account needed) and tried it on a page of my worst handwriting.

What it actually looks like

After installing MacTeX (TeX64 needs an existing TeX distribution — it'll tell you if it can't find one), I opened my project and dropped in a photo of my notebook.

A few seconds later, this appeared in my .tex file:

\begin{align}
  \frac{\partial \rho}{\partial t} + \nabla \cdot (\rho \mathbf{u}) &= 0 \\
  \rho \left( \frac{\partial \mathbf{u}}{\partial t} + \mathbf{u} \cdot \nabla \mathbf{u} \right) &= -\nabla p + \mu \nabla^2 \mathbf{u}
\end{align}

My handwritten Navier-Stokes equations, correctly transcribed, sitting right in my document in editable LaTeX. No switching apps. No clipboard. Just there.

I tested it on a few more pages. Printed math from a textbook screenshot? Near-perfect. My cleaner handwriting? Very good. My worst late-night scrawl? Mostly correct, with a few characters that needed manual fixing.

The pattern I noticed: TeX64 is excellent on math notation specifically. The structural stuff — \frac, \int, \sum, matrix brackets — comes through cleanly. Individual symbols occasionally need correction, but the scaffolding is almost always right.

The workflow I landed on

Here's what actually worked for my paper:

For each section of notes:

Photograph the page (phone camera, decent lighting)
Drop into TeX64 — OCR runs automatically
Read through the output, fix any misread symbols
Use Axiom (TeX64's AI assistant) to clean up formatting

That last step was something I didn't expect to use much but ended up relying on constantly. Axiom can read your compile logs — and since OCR output often has subtle structural errors (mismatched brackets, missing \end tags), those errors showed up frequently.

Instead of debugging LaTeX by hand, I'd ask Axiom: "What's wrong with this compile?" It would look at the actual log, identify the line, and show me a diff. One click to apply.

Example interaction:

Me: "Why is this not compiling?"
Axiom: "Line 312: \begin{align*} is not closed. Here's the fix:"
[shows diff]
[I click Apply]
Done.

That flow — photograph → OCR → Axiom cleanup → compile — got me through forty pages of notes in about two days instead of the week I'd budgeted for.

SyncTeX made verification fast

One thing that helped enormously with checking my work: SyncTeX is built in. You click anywhere in the PDF and jump to the corresponding source line. Click in the source and jump to the PDF location.

For verifying that a converted equation rendered correctly, this is incredibly useful. Instead of manually scrolling through both windows to find where something is, you click once and you're there.

Honest limits

macOS only. This is a hard stop — TeX64 doesn't run on Windows or Linux.

You still need MacTeX or TeX Live installed. TeX64 is the editor; it needs an external TeX distribution to compile. The setup takes maybe 20 minutes if you haven't done it before (TeX64 will walk you through it if MacTeX is missing).

Handwritten text OCR isn't as strong as math OCR. This tool is clearly optimized for mathematical notation. Regular handwritten prose came through with more errors, so I still typed out my non-equation text.

Free tier has limits. For a paper's worth of OCR, you'll likely bump into the usage cap and want the paid plan. That said, it's worth trying on free to see if the accuracy meets your needs before committing.

The one thing that changed my workflow

Before TeX64, the OCR step and the editing step were two separate places in my brain. I had to context-switch between "get the LaTeX" mode and "write the paper" mode.

Having OCR inside the editor eliminated that. When I'm looking at a page of notes and need to pull an equation into my document, I don't leave the app. I drop the image. It appears. I keep writing.

That's it. That's the whole difference. And for paper-writing momentum, it turned out to matter a lot.

If you're on a Mac and you're facing a stack of handwritten research notes: tex64.com. Worth a try.

I Finally Ditched Overleaf for a Local LaTeX Editor — Here's What Actually Works

TeX64 — Sun, 29 Mar 2026 11:15:18 +0000

Last October, I was thirty pages from finishing my master's thesis draft when Overleaf hung. Not an error. Not a crash. Just... spinning. "Compiling" for four minutes. Then a timeout.

I refreshed. It happened again. It was 11 PM, the university Wi-Fi was holding up fine, but Overleaf was clearly under load. Apparently thesis season is thesis season for everyone.

That night, I decided I was finally going to figure out local LaTeX on my Mac.

What I Actually Needed

I'd tried local setups before. The problem wasn't compiling — MacTeX handles that fine. The problem was the editing experience. After two years of Overleaf, I'd gotten used to certain things:

Equation rendering as you type — seeing math rendered without a full compile
Some kind of input assist for math symbols — I can never remember \varepsilon vs \epsilon, or exactly how \underbrace nests
Smart error handling — Overleaf at least shows you which line errored. Bare TeX errors are cryptic.

TeXShop is great but stripped-down. VS Code + LaTeX Workshop is powerful but took me three hours to configure properly (and the SyncTeX setup broke twice). TeXstudio works but feels like a Windows app wearing a thin macOS disguise.

I needed something that felt like a real Mac app and didn't require a weekend of configuration to use.

Enter TeX64

A colleague mentioned TeX64 in a Slack thread about local LaTeX setups. I downloaded it, and within twenty minutes I had my existing project compiling.

Let me walk you through what actually surprised me.

The Visual Math Palette

This was the thing that made me feel like someone actually thought about the experience of writing math.

TeX64 has a symbol palette that lets you build equations by clicking — integral sign, limits, numerator, denominator — and shows you the rendered output in real time. The LaTeX it generates is completely standard and hand-editable afterwards.

Here's what this actually saves me: I write a lot of probability and statistics. I can never remember:

Is it \mathbb{E} or \mathds{E}?
How do I get a properly sized conditional probability bar in P(A | B)?
What's the command for the Hadamard product again?

Instead of tab-switching to a LaTeX reference site and losing my train of thought, I click the symbol, it inserts, and I keep writing. It sounds like a small thing. Over a 120-page document, it adds up.

Axiom: The AI That Actually Reads Your Errors

TeX64 comes with an AI assistant called Axiom. I was skeptical — I've seen a lot of "AI writing assistants" that basically just dump generic suggestions.

Axiom is different because it reads your compile log and your actual source files together.

Here's a real example from my thesis: I had a \begin{align} block that I'd copied from an older paper and pasted into a new section. Somewhere in the copy-paste, the closing \end{align} got dropped. The compile error I got was:

! LaTeX Error: \begin{align*} on input line 492 ended by \end{document}.

That message, to a LaTeX beginner, tells you essentially nothing useful. Axiom looked at the log and the source and said: "Line 492 opens an align* environment that doesn't close before end of document. I found the likely location for a closing tag — here's the diff."

One click. Fixed.

It also generates LaTeX from natural language, which I use mostly for boilerplate I'd otherwise Google every time: tables, matrix environments, theorem/proof blocks. You describe it, it inserts clean LaTeX, you adjust as needed.

It Runs Entirely Offline

This is the fundamental point for me. The compilation runs on your Mac, using your local TeX installation (MacTeX or TeX Live). No internet means:

No Overleaf timeouts — my M2 MacBook Air compiles a 120-page document in about 8 seconds, every time, regardless of what time of day it is
No data going to a server — for sensitive research, this matters
Works on trains, planes, cafes with spotty Wi-Fi — I wrote a significant chunk of my thesis on a Shinkansen

SyncTeX That Actually Responds

Click a paragraph in the PDF, jump to the source line. Click a source line, highlight it in the PDF. This is standard SyncTeX and Overleaf has it too — but when it's running locally with no round-trip to a server, the jump is instantaneous. It changes how you proof-read. You can actually scroll through the PDF and hop back to fix things fluidly.

What You Should Know Before Switching

I want to be honest about the limitations, because "I found a thing and everything is perfect now" is not how software works.

It's macOS only. If you need to hand off to a Windows collaborator who also wants to compile locally, they'll need a different tool.

You still need MacTeX or TeX Live. TeX64 is the editor; it doesn't ship with a TeX distribution. Installing MacTeX takes about 20 minutes the first time (it's a ~4GB download). After that, everything's local.

Real-time collaborative editing doesn't exist here. If you and your advisor are doing live back-and-forth edits simultaneously, Overleaf still wins. My workflow was to share via GitHub and Overleaf was only for sync, not real-time co-editing, so this wasn't a dealbreaker.

Heavy AI and OCR features have usage limits on the free tier. The basic Axiom functionality and the visual palette work without a paid plan. Heavier OCR workloads or very frequent AI completions may require upgrading.

My Actual Workflow Now

For context: I'm a grad student in applied math. I write a lot of equations, a lot of theorems, occasional figures with TikZ.

Open TeX64 with my project (multi-file, one root main.tex)
Compile is fast, SyncTeX is instant
When I need a new equation, palette for the tricky parts, hand-type the rest
When compile fails, Axiom usually finds it in one try
PDF opens in a side panel, SyncTeX to jump around while proofreading

I've been on this setup for about five months. I have not had a single "Overleaf is slow right now" moment. That alone was worth the switch.

If you're on a Mac and you're done with the "Overleaf is timing out again" problem, give TeX64 a try. Free to download, you can have a project compiling within an hour if you already have MacTeX installed.

I Wasted Hours Picking LaTeX Packages. Then I Tried Asking an AI That Reads My Project

TeX64 — Sun, 29 Mar 2026 11:14:19 +0000

Every LaTeX user has been there.

You want to do something — display source code, format a theorem, draw a diagram — and you know a package exists for it. But which one? There are always three or four candidates, and they're all slightly different. You open the CTAN docs, they're 80 pages long. You search Stack Overflow, you find a thread from 2011 where three people recommend three different things and the accepted answer says "it depends."

Thirty minutes later you've committed to one package without really understanding why, and you're already second-guessing yourself.

This was my life for most of my master's thesis. Then I started using TeX64, a local-first LaTeX editor for macOS, and specifically its AI assistant called Axiom. And the "which package?" problem basically disappeared.

The specific problem with package discovery

The issue isn't that documentation is bad. It's that when you're trying to pick a package, you're asking a comparative question: "Given that I want to do X, and given what's already in my project, which option fits best?"

That question doesn't have a good answer in a single package's documentation. You need someone who knows the whole ecosystem, knows your context, and can give you a recommendation with a reason.

Google can get you close, but it gives you generic advice. Stack Overflow threads are either too general ("use whatever you like!") or too specific to someone else's setup. CTAN is comprehensive but not opinionated.

What I wanted was something like asking a more experienced co-author: "Hey, which package would you use for this?"

What Axiom does differently

Axiom is the AI assistant built into TeX64. What makes it actually useful for package selection is this: it reads your entire project before responding. Not just the file you have open — all your .tex files, your compile log, your .bib file.

So when you ask "which package should I use for X?", it answers in the context of your actual setup. It knows what you've already loaded, what your document class is, what errors you're getting.

Here's an example. I was writing a paper and wanted to add algorithm pseudocode. I asked:

"I need to write algorithm pseudocode. What's the best package right now — algorithm2e, algorithmicx, or something else?"

Axiom replied:

"Both are actively maintained. algorithm2e is self-contained and simpler to configure — good if you just need standard pseudocode without much customization. algorithmicx with algpseudocode gives you more control over formatting and is closer to the Algol style you see in CS papers. Since your document class is IEEEtran, I'd suggest algorithm2e — it plays well with IEEE margins without extra tuning. Want me to add it to your preamble?"

That's the kind of answer I actually needed. Not generic, not just a list — a recommendation with a reason, grounded in my actual document setup.

The error-based reverse lookup

The other pattern I use constantly: I get an error, and instead of searching for what's missing, I just ask.

Recent example. Compile error:

! Undefined control sequence.
l.83 \ce{H2O}

I pasted it into Axiom and asked what was happening. Response:

"\ce is a command from the mhchem package, which isn't loaded in your document. Add \usepackage[version=4]{mhchem} to your preamble — the version=4 ensures you're using the current API rather than the legacy interface. Here's the diff:"

+ \usepackage[version=4]{mhchem}

One click to apply. That took about ten seconds total.

Before TeX64, I would have searched "LaTeX undefined control sequence ce", found a thread that mentions mhchem, figured out which version option to use, and applied it manually. Maybe five minutes on a good day. Now it's ten seconds.

The diff-before-apply design

Something I appreciate about how Axiom is built: it never modifies your files silently. Every change goes through a diff display first, and you confirm before it's applied.

This matters more than it sounds. I've used other AI-in-editor integrations that just... change things. Then you don't know what changed, you're not sure if the change is correct, and your confidence in the document erodes.

Axiom shows you the change, explains it, and waits for your confirmation. If I disagree with the suggestion, I can just say no and ask for a different approach. The files stay untouched until I explicitly say yes.

How it handles "I don't know what I need"

Sometimes you don't even know what you're looking for. You just know the output looks wrong.

I tried: "My numbered lists inside theorem environments are using the wrong counter — the list items are numbered 1, 2, 3 but they inherit the theorem number weirdly. How do I fix this?"

Axiom figured out I was mixing enumerate with amsthm in a way that caused counter conflicts, suggested using enumitem with \setlist to reset counters inside theorem environments, and showed exactly where to add what.

It could have just recommended enumitem in the abstract. Instead it diagnosed the specific problem in my specific setup. That's the part that actually saves time.

Honest limitations

A few things worth knowing before you dive in:

macOS only. TeX64 is a native Mac app — Apple Silicon and Intel both work. No Windows version.

You still need a TeX distribution. TeX64 is an editor, not a compiler. You'll need MacTeX or TeX Live installed separately. TeX64 has a built-in environment checker that walks you through the installation if you don't have it — so it's not a hidden trap, but it's not plug-and-play either.

AI features have usage limits on the free tier. The free plan is enough to get a feel for how Axiom works. If you're writing regularly and asking Axiom questions daily, you'll probably want a paid plan. Heavy OCR and AI usage requires Basic or Pro.

Axiom is helpful but not infallible. Occasionally it suggests a package that technically works but isn't the optimal choice for a particular edge case. Especially with more obscure packages, the recommendations are good but worth double-checking.

The actual time savings

Before TeX64, I'd say package-related detours were costing me 30-60 minutes per writing session during my thesis. Each "which package for this?" question, each undefined command error, each "why isn't this rendering right?" moment triggered a search-and-experiment loop.

With Axiom, those questions take seconds to minutes. The answer comes with context and a diff. I say yes, it's done.

The cumulative effect over a 200-page thesis is significant.

If you're on macOS and writing LaTeX regularly, it's worth trying. Free tier, no account required to start. tex64.com

I Used to Retype Every Equation from Old PDFs. Here's How I Stopped.

TeX64 — Fri, 27 Mar 2026 09:52:41 +0000

There's a particular kind of pain that only LaTeX writers know: you're working on a new paper, you need an equation from an old PDF — your own thesis from three years ago, a colleague's preprint, a textbook chapter — and the .tex source file is gone. Just the PDF.

So you open both windows side by side and start retyping.

\mathbb{E}_{q_\phi(z|x)}\left[\log p_\theta(x|z)\right] - D_{\mathrm{KL}}\left(q_\phi(z|x) \| p(z)\right)

Symbol by symbol, subscript by subscript. You compile. Something's off. You scan back through. Missed a closing brace on line 3. Fix it. Recompile. Now the spacing is wrong because you typed \mathbb{E} where it should have been \mathcal{L}. Another fix.

Twenty minutes for one equation. You have eleven more to go.

The "obvious" solution and why it's still annoying

Most people who've been through this enough times have landed on Mathpix. It's genuinely excellent at what it does — take a screenshot of an equation, get back LaTeX. The accuracy on printed math is remarkable.

But here's what the Mathpix workflow actually looks like in practice:

Switch to Mathpix
Trigger the screenshot tool
Drag over the equation
Wait for conversion
Copy the result
Switch back to your LaTeX editor
Paste it in the right place
Switch to Mathpix for the next one
Repeat

That's eight steps per equation. If you have thirty equations to extract from an old paper, you'll execute that loop two hundred and forty times. The individual steps are tiny, but the context switching is real — every time you jump between apps, you lose a tiny bit of momentum. After an hour of it, you feel vaguely exhausted without having written a single original sentence.

There are also open-source alternatives like pix2tex (LaTeX-OCR) and texify, which are free and run locally. But they all share the same fundamental problem: they exist outside your editor.

What "OCR inside the editor" actually means

I came across TeX64 — a local-first LaTeX editor for macOS — while looking for something to replace my aging TeXShop setup. The OCR feature wasn't even what I was initially interested in, but it's what I kept coming back to.

Here's what TeX64's OCR actually does differently: instead of being a separate application you invoke and paste from, it's integrated directly into the editor. You trigger it with a keyboard shortcut, drag over any equation anywhere on your screen (a PDF in Preview, a browser page, a screenshot you have open), and the converted LaTeX code appears at your cursor position.

No app switch. No clipboard. No paste.

The first time I used it, I spent a genuinely embarrassing moment looking around to see if something had gone wrong because it felt too fast and too simple to have actually worked.

Practical walkthrough

Say I'm writing a new paper and I need to reuse the GMM likelihood derivation from my master's thesis (only have the PDF).

With TeX64, the process is:

Open the PDF in a separate window (Preview, or TeX64's built-in PDF viewer — whichever you prefer)
Position your cursor in the .tex file where you want the equation
Hit the OCR shortcut
Drag over the equation in the PDF
The LaTeX code appears at your cursor

No step 3 that's "switch apps." No step 5 that's "paste." The editor is already focused; the code goes directly in.

For a moderately complex equation like this one:

\log p(\mathbf{x}) = \log \sum_{k=1}^{K} \pi_k \mathcal{N}(\mathbf{x} \mid \boldsymbol{\mu}_k, \boldsymbol{\Sigma}_k)

TeX64 gets it right on the first try about 90% of the time in my experience. When it doesn't (usually a subscript issue or a missing brace), there's another feature that saves the day.

When OCR makes a small mistake: Axiom to the rescue

TeX64 has a built-in AI assistant called Axiom that reads your compile logs and proposes fixes with actual diffs. When an OCR-extracted equation fails to compile, Axiom looks at the error message and typically identifies the specific issue in about two seconds.

The workflow becomes:

OCR extracts equation (90% chance it's perfect)
If compile error → Axiom reads the log, shows diff, one click to fix

Compared to staring at a compile log that says ! Missing } inserted somewhere in a 500-line file, this is a meaningful time save.

Honest limitations

macOS only. TeX64 is exclusively for Mac (Apple Silicon and Intel both work great). If your lab runs Windows or Linux, this isn't an option for you.

You still need MacTeX or TeX Live. TeX64 is an editor, not a full LaTeX distribution. You need a working TeX installation separately. The app will walk you through this if you don't have one, but plan for a 30-minute setup if you're starting fresh.

Free tier has limits on OCR volume. There's a free tier that's genuinely useful for getting started, but if you're extracting dozens of equations a day, you'll likely want one of the paid plans. It's reasonably priced compared to Mathpix, but it's not free for heavy use.

Not for real-time collaboration. If you need multiple people editing the same document simultaneously, Overleaf is still the right tool. TeX64 is local-first and built for individual work.

The bottom line

The equation-from-PDF problem isn't hard to solve, but most solutions involve adding a tool outside your editor and living with the friction. TeX64 solves it by putting OCR inside the editor, which turns out to make a bigger difference than you'd expect.

I've been using it for my PhD thesis for about eight months now. The OCR feature alone has probably saved me north of ten hours of retyping time, and that's a conservative estimate.

If you're on a Mac and write LaTeX regularly, it's worth spending twenty minutes with it. You can download it at tex64.com — the free tier is enough to get a real sense of whether the workflow works for you.

My TikZ Diagrams Kept Failing to Compile — Here's What Finally Fixed It

TeX64 — Fri, 27 Mar 2026 08:54:24 +0000

If you've written TikZ diagrams in LaTeX, you've probably hit this wall: the diagram looks perfectly fine in your head, you compile, and then a wall of cryptic error messages appears in the log.

Not errors you can fix in 30 seconds. Errors like:

! Package pgf Error: No shape 'rounded rectangle' is known.
<to be read again>
               \relax
l.94 }

You look at line 94. It's just a closing brace. The actual problem is twenty lines earlier, in a \usetikzlibrary call that's missing a library you didn't know existed.

I spent three hours on this exact problem before a lab mate pointed me toward TeX64. I want to share what I learned.

Why TikZ Errors Are Especially Painful

Regular LaTeX errors are annoying but usually interpretable. "Undefined control sequence" means you misspelled a command. "Missing $ inserted" means you forgot math mode. There's a 1:1 relationship between the message and the fix.

TikZ errors don't work this way. The error propagates through layers of PGF internals before surfacing, so by the time you see the message, you're looking at the wrong line number pointing at the wrong part of your code.

Common TikZ error traps that cost me hours over the years:

1. Library fragmentation

TikZ features are split across dozens of libraries: shapes.geometric, shapes.misc, shapes.symbols, arrows.meta, calc, positioning, fit, backgrounds... The default installation gives you almost nothing. Every time you use a new shape or feature, you need the right library, and there's no autocomplete telling you which one.

% Need diamond? That's shapes.geometric
% Need cloud? That's shapes.symbols
% Need rounded rectangle? That's shapes.misc
% Need to do math in coordinates? That's calc
\usetikzlibrary{shapes.geometric, shapes.misc, shapes.symbols, calc, positioning}

You only learn this by hitting errors and reading the manual. Or spending 20 minutes on a StackOverflow search.

2. LuaLaTeX-only libraries

graphdrawing, force, layered — these only work with LuaLaTeX. If you're using pdfLaTeX (which most people do by default), they fail silently or with a confusing error message. Switching to LuaLaTeX means re-checking whether all your other packages are compatible.

3. Package option conflicts

TikZ depends on xcolor. Beamer also loads xcolor. If the options conflict, you get:

! LaTeX Error: Option clash for package xcolor.

The fix is to load xcolor explicitly with the right options before tikz, but figuring out which options are clashing requires reading both packages' source code or getting lucky on a forum.

4. Externalization path issues

If you use PGFPlots with external data files, the path resolution depends on where LaTeX thinks the working directory is — which depends on your editor, your build system configuration, and your project structure. Move one folder and nothing works.

The Standard Approach and Its Limits

For years, my workflow was: get an error → copy the relevant part of the log → paste into ChatGPT → read the explanation → manually apply the suggested fix → compile again → repeat.

This works, but it has friction. You have to:

Know which part of the log is actually relevant
Provide enough context about your project (what packages you're using, what your file structure looks like)
Manually apply the fix
Hope the AI's suggestion doesn't break something else in your project it doesn't know about

What TeX64 Does Differently

TeX64 is a local-first LaTeX editor for macOS. All compilation runs on your machine — no cloud, no internet required. It includes an AI assistant called Axiom that's specifically built for LaTeX, and it handles the TikZ error situation fundamentally differently.

Axiom reads your compile log automatically. You don't paste anything. You compile, the error appears, you switch to the Axiom panel and say "fix this error." Axiom already has the log.

Axiom knows your entire project. It has access to all your .tex files, your preamble, your build configuration. When I got the xcolor conflict error, Axiom knew I was using Beamer (I hadn't told it anything) and responded: "The conflict is between Beamer's xcolor options and TikZ's. Load xcolor explicitly before both packages with the dvipsnames option."

Axiom shows diffs, not just explanations. Instead of getting an explanation you have to manually implement, you get a before/after diff. One click applies it. Axiom never modifies files without showing you what it's about to do.

Here's how it looked for my rounded rectangle problem:

- \usetikzlibrary{arrows.meta}
+ \usetikzlibrary{arrows.meta, shapes.geometric, shapes.misc}

Applied, recompiled, it worked. The three hours I'd already spent staring at the same error felt absurd in retrospect.

Other Ways This Helped My Workflow

Once I started using TeX64 more seriously, Axiom helped in situations I hadn't anticipated.

arXiv citation lookup. I'll tell Axiom "add a citation for [paper title]" and it searches arXiv, finds the paper, and inserts the BibTeX entry. My bibliography workflow went from "open browser, find paper, copy BibTeX, paste into bib file" to "describe the paper in one sentence."

Generating TikZ code from descriptions. I described a flowchart I wanted ("three boxes connected by arrows with a decision diamond in the middle") and Axiom generated working TikZ code. Not always perfect, but it gives you something to edit rather than starting from a blank screen.

Log-first error diagnosis. For errors that aren't TikZ-specific — undefined reference, missing endcsname, etc. — Axiom spots patterns across the whole log that you'd miss reading line by line.

Honest Limitations

TeX64 is macOS-only. If you're on Windows or Linux, this isn't an option (yet).

You need a working TeX distribution. MacTeX is the standard — it's about 4GB and takes a bit to install, but TeX64's environment diagnostics will guide you through it if you haven't set it up.

The AI features have usage limits on the free tier. Heavy Axiom use (multiple projects, lots of back-and-forth) may require a paid plan.

Real-time collaboration isn't built in. If you're co-writing a paper with several people simultaneously, Overleaf is still the better choice. TeX64 is for the solo-writing workflow.

Is It Worth Switching From Overleaf?

If you're collaborating with multiple people in real-time: maybe not. Overleaf's killer feature is the shared real-time editing, and TeX64 doesn't replicate that.

If you mostly write alone (which is most thesis writers, most of the time): local LaTeX has real advantages. No compile minute limits. No internet dependency. Faster compilation. My 150-page thesis document compiles in under 10 seconds on an M2 MacBook Air. On Overleaf's free tier, that same document would time out.

The Axiom integration is what tips it over for me. TikZ errors are just one example — having an AI that understands your whole project and proposes specific diffs is meaningfully different from pasting logs into a chat interface.

Getting Started

If you want to try it: tex64.com. Free tier is available. You'll need MacTeX installed — TeX64's environment diagnostics will walk you through it if you're starting from scratch.

For TikZ-heavy documents especially, I'd say the time savings from Axiom alone justify the setup time. I've lost days over the years to TikZ compilation errors that Axiom would have fixed in 30 seconds. That math doesn't take long to work out.

I Found a Way to Preview LaTeX Equations Without Compiling Every Time

TeX64 — Fri, 27 Mar 2026 07:55:48 +0000

There's a specific kind of frustration that only LaTeX users know.

You've been staring at a block of nested fractions and summations for ten minutes. You think it's right. You hit compile. You wait 40 seconds. The PDF opens. The equation is on line 3 of the PDF and it's... almost right. One subscript is off. You fix it, compile again, wait again.

By the time you get the equation right, you've forgotten what point you were trying to make with it.

I did this for two years. Then I found a different way.

What I Actually Needed

The compile loop isn't just slow — it's cognitively expensive. Every time you have to wait, you break focus. And the worst part is that you don't actually need to compile the whole document just to check whether an equation looks right. You just need to see the rendered output while you're building it.

What I wanted was simple: click a symbol, see it rendered, immediately.

TeX64's Visual Math Palette

I came across TeX64, a local-first LaTeX editor for macOS (tex64.com), while looking for alternatives to my TeXShop setup.

The feature that immediately caught my attention: a visual equation palette that shows you a live-rendered preview as you click symbols and build your equation — with zero compilation.

Here's what the workflow looks like:

Open the palette
Click the integral symbol → \int_{a}^{b} appears
Fill in the bounds and integrand
The rendered equation updates in real-time in the preview pane
Happy with it? Copy the LaTeX code and paste into your .tex file

The output is completely standard LaTeX — not some proprietary format — so you can hand-edit it afterward or drop it into any project.

For equations I know cold (like basic derivatives), I still type them by hand. But for anything involving unusual notation — multi-index tensor expressions, operator norms, custom arrow decorations — the palette is way faster than guessing the command and compiling to check.

The Other Parts of TeX64 I Use Daily

Beyond the palette, a few other things earned their place in my workflow:

Axiom (the AI assistant)

TeX64 has a built-in AI called Axiom that understands your whole project — all .tex files, compile logs, BibTeX. When a compile error pops up, Axiom reads the log and shows you a diff of exactly what to fix. Not a vague hint. An actual before/after.

I had a mysterious Missing \begin{document} error that turned out to be a broken \usepackage argument three files away. Axiom found it. I would have spent 20 minutes on that.

Axiom also takes natural language: "write the Gaussian integral with substitution" → produces valid LaTeX. Useful for equations you only write once a year and never bother memorizing.

Equation OCR

Paste a screenshot — handwritten notes, a textbook page, a PDF — and TeX64 converts the math to LaTeX. It handles both handwriting and printed equations. If you've used Mathpix before, this is that, but integrated into the editor.

I photographed a whiteboard derivation from a lecture and had it in my thesis source file in about 15 seconds.

SyncTeX

Click anywhere in the PDF → jump to the corresponding source line. Click a source line → jump to the PDF. This is standard in most decent LaTeX setups, but TeX64's implementation is snappy and works out of the box.

Offline, local-first

Everything compiles on your Mac. No internet required. No files going to a cloud server. If your university VPN goes down in the middle of a deadline crunch, nothing changes.

Honest Limitations

A few things worth knowing before you download:

macOS only — Apple Silicon and Intel both supported, but no Windows or Linux
You still need MacTeX or TeX Live installed separately for compilation (the equation palette preview works without it, but actual document builds need a TeX distribution)
No real-time collaboration — if you're co-authoring with someone who needs simultaneous editing, Overleaf still wins that specific use case
The AI and OCR features have usage limits on the free tier; heavier use requires a Basic or Pro plan

Getting Started

Download from tex64.com. There's a free tier and you don't need to create an account to start using it — just download and open.

If you don't have MacTeX, TeX64 will detect this on first launch and walk you through the installation. That part takes maybe 15 minutes.

The Takeaway

The compile-wait-check loop is one of those frictions that feels normal because you've just accepted it. But once you've used a real-time equation preview for a week, going back feels awful.

TeX64's visual palette didn't change my entire workflow — I still write LaTeX, I still compile, I still get errors. But the part that used to be the most interruptive (verifying equation syntax mid-thought) is now basically instant.

If you're on a Mac and writing math-heavy documents, it's worth trying.

→ tex64.com

I Was Paying $10/Month Just for Math OCR — Here's What I Use Instead

TeX64 — Fri, 27 Mar 2026 07:27:08 +0000

For two years I paid Mathpix $10 a month to convert math equations from images into LaTeX. It was worth it at first. Snap a photo of a textbook page, get clean LaTeX in seconds — genuinely magic.

But then I started doing the mental math. How often was I actually using it? Some months, every day. Some months, maybe a dozen times. And every month, without fail, $10 charged to the card.

The real problem wasn't the price. It was the workflow.

The Actual Problem With "Tool Per Task" Setups

My routine looked like this: I'm in my LaTeX editor, I need a formula from a lecture slide PDF. So I minimize the editor, open Mathpix, snip the equation, copy the LaTeX, switch back to the editor, paste it, resume writing.

Six steps. Every time. For what should be a two-second operation.

I'm not saying it was unbearable. It wasn't. But multiply that by 20 equations in a paper and you've added a non-trivial amount of context-switching friction to your day. I kept wondering: why is OCR a separate app at all?

What I Looked At First

Before I found what I ended up using, I tried a few things:

Pix2Text — An open-source Python library with surprisingly good accuracy. It does what Mathpix does, for free. But it lives in the terminal. There's no integration with any editor, so the copy-paste ceremony doesn't go away. I'm not going to write a VS Code plugin for myself every time I want to avoid a SaaS subscription.

SmartSnip — A macOS snipping tool that outputs LaTeX. Clean UI, good accuracy, even has a local model option. I actually used this for a month. But again: it's a standalone tool. Same switching problem as Mathpix.

Browser-based options — DeepSeek's formula OCR is shockingly good and free. But "open browser, upload image, copy result" isn't exactly seamless when you're deep in a 60-page document.

Then I Found TeX64

A comment on a Japanese tech blog mentioned that TeX64, a macOS LaTeX editor, had OCR built into the editor itself. I'd never heard of it.

I downloaded it that evening.

The editor is solid. It detected my existing MacTeX installation without any configuration, opened my thesis project, and rendered the PDF in a split view. SyncTeX worked out of the box — click a paragraph in the PDF, jump to the source line. That alone was a quality-of-life improvement over my previous setup.

But the OCR: I took a screenshot of an equation from a lecture slide — a moderately complex one with summations and subscripts — and pasted it into TeX64. Three seconds later, the cursor was sitting right after:

\sum_{k=0}^{n} \binom{n}{k} x^k y^{n-k} = (x + y)^n

I didn't touch another application. I didn't open a browser. I didn't leave my editor.

That's the thing. OCR in TeX64 isn't a feature bolted on the side — it's integrated into the editing flow. You stay in the editor.

What Else TeX64 Does That I Didn't Expect to Care About

Axiom, the AI assistant: When I get a compile error, I used to copy the log, paste it into ChatGPT, and wait for a response. Axiom reads the actual compile log, figures out the problem, and shows me a diff with the fix. One click to apply. It reads all my .tex files and my BibTeX, so it understands the full project context. It also searches arXiv and can insert BibTeX entries directly.

Visual equation palette: Click symbols to build equations, see the rendered output in real time. I know LaTeX well enough that I don't need this constantly, but for complex matrix notation or obscure symbols, it beats hunting through documentation.

Local-first: Everything compiles on my Mac. No cloud, no internet required for compiling. My thesis drafts don't touch anyone's servers. This matters more to me than I expected.

What You Should Know Before Trying It

TeX64 is macOS only. If you're on Windows or Linux, stop reading here — it's not for you.

You still need MacTeX (or TeX Live) installed separately. TeX64 doesn't bundle a TeX distribution. First-time setup takes a bit, but TeX64's environment diagnostics walk you through it and detect what's missing.

The OCR has a free tier. If you're doing heavy OCR work daily, you'll hit limits and need a paid plan. For most users — occasional to moderate equation conversion — the free tier is fine or the paid plan is cheaper than Mathpix anyway.

Real-time collaborative editing isn't a thing here. If you and your advisor are both editing a document simultaneously in Overleaf, TeX64 doesn't replace that. It's for solo work.

Should You Try It?

If you're a macOS user who writes LaTeX regularly — for a thesis, for research papers, for anything that involves equations — and you're currently paying for a separate OCR tool, the answer is probably yes.

The free tier doesn't even require an account to start. Download, open your project, try the OCR once. If it clicks, it clicks.

tex64.com

My thesis was taking forever to write — turns out LaTeX was the bottleneck, not me

TeX64 — Fri, 27 Mar 2026 06:31:10 +0000

I was three months from my thesis deadline writing maybe 200–300 words of actual content per day in LaTeX. Not because I didn't know what to write — I had notes, outlines, and research. The words just weren't making it onto the page fast enough.

One evening I timed myself. In a 60-minute writing session, here's where the time actually went:

22 minutes: Writing actual text
19 minutes: Debugging compile errors
12 minutes: Looking up math syntax
7 minutes: Managing bibliography entries

That's 38 minutes — more than half my session — fighting with LaTeX tooling. I wasn't slow at writing. I was slow at everything around writing.

The compile error trap

Every LaTeX writer knows the loop: write something, compile, get an error, open the log, stare at 200 lines of output, find the relevant line, understand what it means, fix it, compile again.

The log output for a missing package looks like this:

! LaTeX Error: File `algorithm2e.sty' not found.

Type X to quit or <RETURN> to continue,
or enter new name. (Default extension: sty)

Enter file name:

If you're experienced, you immediately know: install the package, add \usepackage{algorithm2e}. If you're mid-thesis and context-switching constantly, it takes a minute to even process what the error is saying.

Now multiply that by every session for months.

Finding TeX64

I came across TeX64 through a GitHub discussion thread about local-first LaTeX editors for macOS. It's a Mac-native LaTeX editor with something called Axiom — an AI assistant that reads your entire project (all .tex files, your compile logs, your .bib file) before responding.

The "reads your compile log" part caught my attention.

I downloaded it, opened my thesis project, and tried to trigger an error on purpose by removing a \usepackage line. Compiled. Axiom showed up with the error explanation and a diff showing exactly what to add back. I clicked apply.

That was... it. No log-reading, no searching, no manual edit.

I've been using it for a few months now, and here's what's actually changed.

What Axiom does that generic AI can't

When I paste a LaTeX error into ChatGPT, I get a reasonable but generic answer. "This usually means the package is missing — try adding \usepackage{bm} to your preamble."

Axiom knows my preamble. It knows what packages I'm already using, which files are included via \input{}, what my bibliography file is called, and what the root file is. So when it answers, it's answering about my specific project, not a hypothetical one.

The diff system is also important. Axiom shows you exactly what change it wants to make before touching anything. You can read the diff, decide whether it looks right, and either apply it or tell Axiom to try something else. Your files never change silently.

Equation input without syntax lookup

TeX64 has a visual math palette — click symbols to build equations and see them rendered in real time. I know some LaTeX writers find palettes patronizing, but for me the issue was always the less common environments.

I know \frac{}{} and \sum by heart. But \begin{cases} vs \begin{array} for piecewise functions? The exact syntax for \underbrace? Whether it's \mathbf or \boldsymbol for vectors in a particular context? Those I had to look up every time.

The palette handles all of those. And the rendered preview means I can see the output immediately rather than compiling just to check whether a symbol looks right.

The other thing — OCR. You can paste a screenshot of handwritten notes or a printed equation from a PDF, and TeX64 converts it to LaTeX. I started photographing whiteboard derivations from my advisor's office and pasting them directly into my thesis. That workflow alone has probably saved me a few hours total.

Bibliography management that doesn't break flow

My old reference workflow: find the paper on Google Scholar, click "Cite", select BibTeX, copy the entry, switch to my .bib file, paste, fix any formatting issues, switch back, write \cite{key}, compile to verify.

That's not terrible, but it pulls you completely out of writing mode. You're context-switching to a search engine, a citation manager, a text file, and back.

With Axiom, I describe what I want to cite and it searches arXiv. I pick from the results and it adds the BibTeX entry to my .bib file. The whole thing happens inside the editor without a browser tab.

The local-first part matters more than I expected

TeX64 is local-first — everything runs on your Mac. I use an M2 MacBook Air and my 140-page thesis compiles in about 9 seconds. No waiting for a server.

I was on Overleaf before, and the compile waits weren't terrible — but they existed. There's a kind of cognitive tax to submitting a compile and waiting for a response. When the compile is instant and local, you iterate more freely.

TeX64 also works completely offline for editing and compiling. Only the AI (Axiom) and OCR features need internet. For a researcher who sometimes works on planes or in places with flaky wifi, that matters.

Being honest about the limitations

macOS only. If you're on Windows or Linux, this isn't for you.
You still need MacTeX or TeX Live installed separately. TeX64 is an editor, not a TeX distribution. (It does detect if you're missing one and walks you through installation.)
No real-time collaboration. If you need multiple people editing the same document simultaneously, Overleaf still wins on that front.
Heavy AI/OCR usage requires a paid plan. The free tier is reasonable for getting started, but if you're relying on Axiom constantly, you'll want to look at the paid tiers.

Would I recommend switching?

If you're writing a long-form LaTeX document on a Mac and you're spending more time on tooling than on content, yes — try it. The friction reduction is real.

The core insight from my timing exercise was that my writing problem wasn't a writing problem. It was an environment problem. Fixing the environment didn't make me a better writer, but it cleared enough space that the writing could actually happen.

You can download TeX64 at tex64.com. Free to start, no account needed.

Why I Finally Ditched Word's Equation Editor (And What I Use Now)

TeX64 — Fri, 27 Mar 2026 05:41:35 +0000

Let me paint you a picture. It's 11pm. You're halfway through writing a section on Bayesian inference for your thesis. You need to type a posterior distribution formula — nothing exotic, just a fraction with a couple of Greek letters and subscripts.

In Microsoft Word, this is what happens: you leave the keyboard, click "Insert," click "Equation," find the fraction template, click again, navigate to the Greek letters panel, find μ and σ, click back into the numerator field, type the exponential, go back to the denominator…

Five minutes later, you have one equation. And you've broken your flow at least six times.

That was me, about 18 months ago. I'd been a loyal Word user for years, and I want to be fair — Word's equation editor is genuinely fine for simple math. If you're writing a short homework assignment with a handful of formulas, it gets the job done. But when your document has 80+ equations, when you need properly formatted matrices, when you need equation numbering that doesn't drift around when you move paragraphs — that's where it starts to fall apart.

The specific things that broke me

Here's what finally pushed me over the edge:

Equation numbering. Word's equation numbering is surprisingly fragile. Once I had a long chapter with numbered equations, and after reorganizing a few sections, a handful of numbers were wrong. Fixing them took the better part of an afternoon. LaTeX's \label and \ref system handles this automatically.

Matrix input. Word uses its own variant of UnicodeMath syntax that doesn't match standard LaTeX. So \begin{pmatrix} doesn't work — you have to use \matrix() instead. This matters when you're sharing work with collaborators who use LaTeX, or when you need to submit to a journal that wants .tex files.

Performance. Around 90 equations, Word started getting noticeably sluggish. Scrolling, cursor movement, undo — all slightly laggy. Probably the real-time rendering overhead. LaTeX compiles separately and then the PDF is static, so this just isn't a problem.

Why I was nervous about switching to LaTeX

Here's the thing that kept me from switching for too long: I assumed I'd have to memorize a ton of commands.

And yes, for common stuff, LaTeX commands aren't that bad:

\frac{1}{2}      % fraction
\sqrt{x}         % square root
\alpha, \beta    % Greek letters

But once you get into less-common territory — tensor notation, double integrals, custom matrix environments — I found myself constantly interrupting my writing to Google the right syntax. That friction was real, and it made LaTeX feel harder than it needed to be.

Enter TeX64 and its visual math palette

A colleague pointed me toward TeX64, a LaTeX editor for macOS. I was skeptical at first — I'd used other LaTeX editors and found them either overwhelming (TeXShop, Emacs + AUCTeX) or too basic.

What won me over was the interactive math palette.

The concept is simple: it's a panel of symbols, operators, and templates organized by category. You click what you want, and the corresponding LaTeX code gets inserted into your document. But here's the key thing — it also shows you a live rendered preview of what the equation looks like as you build it.

This feels a lot like Word's equation editor (you're still clicking things visually) except the output is real, compilable LaTeX. Once it's in your file, you can hand-edit it, copy it, use it in other documents — it's just LaTeX.

For me, this bridged the gap. I could use the palette for symbols I didn't have memorized, and gradually I found myself typing common ones directly. The palette became a training tool as much as a convenience.

% Example: I used the palette to build this, then learned to type it manually
\mathbf{A} = \begin{pmatrix}
  a_{11} & a_{12} & a_{13} \\
  a_{21} & a_{22} & a_{23} \\
  a_{31} & a_{32} & a_{33}
\end{pmatrix}

The OCR thing is genuinely impressive

TeX64 also has equation OCR built in. You screenshot or photograph a math expression — from a textbook, a whiteboard, a PDF — and it converts it to LaTeX.

I was dubious. But it works. I took a photo of a page from a signal processing textbook, pasted it into TeX64, and got back something I could use with minor edits. The accuracy on printed math is high. Handwritten equations are hit or miss, but even a 70% accurate starting point is faster than typing from scratch.

For thesis work, this is a significant time save when you're referencing formulas from papers or books and don't want to retype everything.

AI error fixing that actually works

TeX64 has an AI assistant called Axiom that reads your compile logs and proposes fixes. This matters more than it sounds.

LaTeX error messages are notoriously cryptic:

! Undefined control sequence.
l.312 \underbrace

Axiom looks at the full log, understands the project context, and tells you something like: "You're missing \usepackage{amsmath} in your preamble — this command requires it." It shows the fix as a diff so you can review before applying.

It also does natural language → LaTeX generation: "Write the formula for the normal distribution" → you get the actual code. Useful when you know what you want mathematically but can't remember the exact syntax.

SyncTeX for large documents

One feature I didn't know I needed until I had it: SyncTeX. This is the bidirectional PDF ↔ source link.

Click somewhere in the compiled PDF → your cursor jumps to that line in the source. Click a line in the source → the PDF scrolls to that part.

When your thesis is 150 pages across 8 files, this is invaluable. "Which file has the equation I'm looking for?" is no longer a problem.

The honest limitations

I want to be upfront about the downsides:

macOS only. TeX64 doesn't run on Windows or Linux. If you're not on a Mac, it's not an option.

You still need to install a TeX distribution. TeX64 doesn't include the LaTeX compiler — you need MacTeX or TeX Live installed separately. This is a one-time setup (about 20-30 minutes), but it's a real step that Word obviously doesn't require.

Not for real-time collaboration. If you're cowriting with someone and need to work simultaneously in the same document, Overleaf is better for that specific use case. TeX64 is a solo writing tool.

Heavy AI/OCR use requires a paid plan. There's a free tier to start, but if you're using OCR or Axiom heavily, you'll hit limits and need to upgrade.

So should you switch?

If you're a Mac user who writes documents with significant math content, and you've started feeling the friction of Word's equation editor — yes, I think it's worth trying.

The visual math palette removes the biggest psychological barrier to LaTeX (the "I have to memorize everything" feeling), and the rest of the editor is genuinely well-designed for academic writing workflows.

The free tier is a good starting point. You can get a real feel for it without committing to anything.

→ tex64.com