Newsroom Turns a Telegram Channel Into a Printed Tabloid, Entirely Offline
A local-first Windows app that ingests authorized channel exports, clusters posts into stories, drafts with a local model that must pass a smoke test before it is allowed to write, and lays out an 11×17 front page.
- Newsroom converts an authorized Telegram channel export into a printed tabloid PDF and an offline e-paper bundle, all on one local Windows machine.
- Its most unusual feature is a fail-closed model gate: a local LLM cannot draft unless its exact model digest has a passing smoke-test record in the database.
- The entire edition build is transactional, so a raise at any stage rolls back every earlier stage rather than leaving a half-built paper.
- The tradeoff for that safety is a one-shot worker you must schedule yourself; the installer does not create a Windows task.
Telegram channels are the opposite of print. They scroll forever, they get edited, they carry corrections buried three posts down. Print is bounded: a fixed 11×17 front page, set once, frozen forever.
Newsroom sits between the two. It is a local-first Windows application that takes an authorized Telegram channel export and prints a newspaper from it. The pipeline runs on your machine, drafts with a local model, and never contacts a hosted AI service.
A Chat App Feeding a Printing Press
The whole pipeline fits in one sentence: ingest a rights-cleared Telegram Desktop JSON export, filter out the greetings and link-only posts, cluster the rest into stories, draft articles, audit those drafts against extracted claims, lay out a tabloid, and export a PDF plus an offline e-paper bundle.
What makes that interesting is not the plumbing. It is the direction of travel. Most publishing tools push a finished article out to social platforms. Newsroom pulls a social platform in and prints it.
The internal Python package is still named channel_press, and the desktop mutex still reads ChannelPress.Desktop, while the product is called Newsroom. That residue is visible evidence of a rename, not a defect. The machine was built under one name and shipped under another.
The Front Door Is a Rights Check
Before any clustering or drafting happens, the pipeline checks rights. That ordering is the point. The README draws a line that most aggregators ignore: being able to read a public channel is not the same as being allowed to republish it.
That single sentence explains almost every other decision in the codebase. It is why the app is local-first. It is why the CLI docstring insists that nothing contacts Telegram, an online model, or a remote host unless an owner explicitly configures it. It is why drafting uses Ollama on the same machine instead of a cloud API: the source text is not yours to ship to someone else's server.
Read that as a product decision rather than a legal disclaimer. The rights boundary is the front door, and everything behind it is built to keep unauthorized content from ever leaving the machine.
An AI That Has to Pass a Test Before It Writes
Here is the part that separates Newsroom from every other "AI writes your newsletter" tool. Before a local model is allowed to draft anything, the code checks whether that exact model has passed a smoke test.
def select_provider(db, channels):
if channels and all(item.is_demo for item in channels):
return FixtureDraftProvider(), "fixture deterministic composer"
candidate = OllamaDraftProvider()
available, message = candidate.available()
if available:
if db is None or model_smoke_record(
db, candidate.model, candidate.model_digest
) is None:
raise PipelineError(
f"Local model {candidate.model} is installed but not tested "
"for this exact digest."
)
return candidate, f"ollama {candidate.model}"
raise PipelineError(
"Fixture drafting is disabled for non-demo channels."
)
The check is keyed to the model digest, not the model name. Swap in a different build of the same weights and the gate closes again, because the digest changed. A model that is installed but untested raises a hard error instead of quietly producing copy.
There is no silent fallback either. Fixture drafting, the deterministic composer that produces repeatable text for demos, is explicitly disabled for real channels. If the gate fails, the build fails. Nothing gets printed.
The editorial logic behind the gate is easy to state and hard to argue with: a draft you cannot audit is a draft you cannot trust. If the model that wrote the copy is not the exact model you tested, you have no idea what it will say. So you do not let it say anything.
The Pipeline Is All or Nothing
The build runs as a single linear pipeline, and every stage writes only to the caller's session. If any stage raises, the whole run rolls back. A retried job cannot leave a half-built edition sitting on disk, which is exactly the failure mode you would expect from a naive multi-step build.
The stage order is fixed: rights check, source window, draft cleanup, clustering, claims, drafting plus an independent audit, story packaging, layout, PDF and QA, e-paper export, edition record. Play with the diagram below to see how a failure at the gate rewinds the entire line.
How a Post Becomes a Story
The editorial middle is where the newsroom logic lives, and it looks less like a chatbot and more like a copy desk. Clustering groups duplicates, photo albums, reply threads, and corrections into single stories so the same event does not print three times.
From those clusters the system extracts claims, then drafts articles with chronology and named entities attached. Before a draft can advance, it is audited against the claims it was supposed to be reporting. A draft that asserts something the source posts do not support does not move forward.
That is a genuinely different shape from a prompt-and-publish tool. The audit step means the model is writing against a checklist it has to satisfy, not just generating plausible prose.
Where It Sits
The natural comparison is not another AI writer. It is the do-it-yourself stack: a cloud AI writing tool, a separate layout app, and a PDF export. Newsroom collapses those into one pipeline with the rights check baked into stage one.
| Dimension | Newsroom | DIY stack (cloud AI writer + layout tool + PDF export) |
|---|---|---|
| Where source text goes | Stays local (Ollama, no hosted AI) | Leaves the machine to a hosted model |
| What starts a draft | A tested, digest-pinned local model or nothing | Whatever model the API returns today |
| Rights handling | Rights check is the first pipeline stage | Handled outside the tool, if at all |
| Failure mode | Whole build rolls back | Partial output, manual cleanup |
| Output | Tabloid PDF plus offline e-paper bundle, frozen edition | Whatever the export button produces |
| Scheduling | One-shot worker you wire up yourself | Usually a hosted service |
One caveat worth stating plainly. Several unrelated projects share the name Newsroom, including SpektrNO/newsroom and kpman/newsroom, and a LinuxLinks writeup that covers the latter. They are separate codebases with separate authors. The name is a coincidence, not a lineage, and none of them is a competitor to this project.
What the One-Shot Worker Costs You
The safety has a price, and the code is honest about it. The detached worker is one-shot by default. It processes up to ten jobs and exits, with no resident daemon keeping watch. The README says it directly: unattended runs need a Windows task or worker that you configure, and the installer does not create one.
- The worker exits after its job batch instead of staying resident, so a build you forget to schedule simply never runs.
- Scheduling is delegated to Windows Task Scheduler and left unconfigured by the installer, which puts the burden on the operator.
- No test suite is visible in the provided file tree, so the transactional guarantees rest on the code's own claims rather than an independent harness.
- The PDF engine is inferred from a headless-browser runtime and a vendored Paged.js, not confirmed by a build file. Treat that detail as an inference.
None of that undercuts the design. It just locates it. Newsroom is a careful, single-machine publishing tool for someone who holds the rights to the content and is willing to run the cron job. It is not a hosted service, and it never pretends to be one.





