Google releases Gemma 4 open models

If you have a basic ARM MacBook, GLM-OCR is the best single model I have found for OCR with good table extraction/formatting. It's a compact 0.9b parameter model, so it'll run on systems with only 8 GB of RAM.

https://github.com/zai-org/GLM-OCR

Use mlx-vlm for inference:

https://github.com/zai-org/GLM-OCR/blob/main/examples/mlx-de...

Then you can run a single command to process your PDF:

  glmocr parse example.pdf

  Loading images: example.pdf
  Found 1 file(s)
  Starting Pipeline...
  Pipeline started!
  GLM-OCR initialized in self-hosted mode
  Using Pipeline (enable_layout=true)...

  === Parsing: example.pdf (1/1) ===

My test document contains scanned pages from a law textbook. It's two columns of text with a lot of footnotes. It took 60 seconds to process 5 pages on a MBP with M4 Max chip.

After it's done, you'll have a directory output/example/ that contains .md and .json files. The .md file will contain a markdown rendition of the complete document. The .json file will contain individual labeled regions from the document along with their transcriptions. If you get all the JSON objects with

  "label": "table"

from the JSON file, you can get an HTML-formatted table from each "content" section of these objects.

It might still be inaccurate -- I don't know how challenging your original tables are -- but it shouldn't be terribly slow. The tables it produced for me were good.

I have also built more complex work flows that use a mixture of OCR-specialized models and general purpose VLM models like Qwen 3.5, along with software to coordinate and reconcile operations, but GLM-OCR by itself is the best first thing to try locally.

I use Claude Code. Codex and Opencode both work too. You could even do it with VScode Copilot.

Here's Gemma's. Qwen's is a bit too long to post here.

  Input format: ISO 8601 string (2026-04-01T16:00:00Z).

  Target format: Unix timestamp (seconds since Jan 1, 1970).

  Year: 2026

  Month: 04 (April)

  Day: 01

  Time: 16:00:00

  Timezone: Z (UTC/Zulu)

  Option A: Manual calculation (too error-prone).

  Option B: Use a programming language (Python/JavaScript).

  Option C: Knowledge of specific dates.

  Let's use Python logic internally to ensure accuracy:

  from datetime import datetime, timezone
  date_str = "2026-04-01T16:00:00Z"
  # Replace Z with +00:00 for ISO format parsing or just strip it
  dt = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
  ts = int(dt.timestamp())
  print(ts)


  Start of 2026 (Jan 1): Approx $1767225600$
  Let's verify the math:
  Epoch starts at 0.
  Seconds in a day: $86400$.
  Number of days from 1970 to 2026 is roughly 56 years.
  $56 \times 365.25 = 20454$ days.
  $20454 \times 86400 = 1,767,225,600$.
  Let's do a precise check via common tools/logic:

  2026-04-01T16:00:00Z
  Date: April 1, 2026.
  Time: 16:00 UTC.
  Using a standard calculator logic for Unix timestamps:
  The timestamp for 2026-04-01T16:00:00Z is 1775060800.

  Check: Is 1775060800 correct?

  Convert back: date -u -d @1775060800 -> Wed Apr  1 16:00:00 UTC 2026. Yes.
  State the timestamp clearly.

  Provide context (the date/time it represents).

They explain it here:

https://unsloth.ai/docs/basics/unsloth-dynamic-2.0-ggufs

For the best quality reply, I used the Gemma-4 31B UD-Q8_K_XL quant with Unsloth Studio to summarize the URL with web search. It produced 4.9 tok/s (including web search) on an MacBook Pro M1 Max with 64GB.

Here an excerpt of it's own words:

Unsloth Dynamic 2.0 Quantization

Dynamic 2.0 is not just a "bit-reduction" but an intelligent, per-layer optimization strategy.

- Selective Layer Quantization: Instead of making every layer 4-bit, Dynamic 2.0 analyzes every single layer and selectively adjusts the quantization type. Some critical layers may be kept at higher precision, while less critical layers are compressed more.

- Model-Specific Tailoring: The quantization scheme is custom-built for each model. For example, the layers selected for quantization in Gemma 3 are completely different from those in Llama 4.

- High-Quality Calibration: They use a hand-curated calibration dataset of >1.5M tokens specifically designed to enhance conversational chat performance, rather than just optimizing for Wikipedia-style text.

- Architecture Agnostic: While previous versions were mostly effective for MoE (Mixture of Experts) models, Dynamic 2.0 works for all architectures (both MoE and non-MoE).