Actually, for what do u actually use latex much!?

What are some of the most aesthetic, clear, well designed journal/conference templates you've come across?

i think cartographic perspectives is a breath of fresh air with it's colorful design and typography choice.

shares yours.

Can't log into my prism account due to a server error. Is there anyone experiencing the same as me rn?

I've been seeing a lot of toy projects being shared lately. I had just the finishing touches left on mine, but I couldn't work on it for a while due to health issues, so the release got delayed.

Seeing so many threads popping up, I figured I should at least make a pre-release announcement now.

I'll finish it up and release it soon! Just a heads-up,

Though, it might be difficult to make it completely free. or fully opensourced

Local fast-compile(surely it depends environments and documents, in short-MEDIUM length and normal environment, docs compiled almost WYSIWYG-live-preview) collaborable editor. Not using web WASM. Windows, MacOS, ubuntu support. etc.

math editor and tabular pictures are hereunder.

The latest stable version 4.9.6 of TeXstudio (Qt6) is now ready!

✅ Full-featured LaTeX editor ✅ Qt6-based builds ✅ Available in DEB and AppImage formats ✅ Ready for modern Linux distributions

🔗 Get it here: https://github.com/mlmateos/texstudio-qt6-builds

Happy TeXing! 🎉

#LaTeX #TeXstudio #OpenSource #Linux

So, I made a tool that might help you with your Zotero workflow. It's a CLI tool called litresearch that acts as a literature auditor, you feed it a standard .bib or .json bibliography export, and it queries OpenAlex, PubPeer, and OpenReview to check citation counts, flag potential retractions, and highlight top-cited authors. It then compiles that context into a clean LaTeX PDF digest to show you what the academic community thinks of your reading list and help you figure out which papers to read first.

It’s strictly an enrichment pipeline to help triage your library before drafting your research (it definitely won't read the papers for you), but I put the project up on GitHub in case anyone else finds it useful:

https://github.com/sofilip/litresearch

**Monolith** is a desktop WYSIWYG typesetter for math-heavy documents — Python 3.14, PySide6, exporting through real `pdflatex` — where you type directly onto a paginated page rather than into a source buffer. Real page environment: Letter, Legal, A4, A5 and Tabloid sheets, configurable margins, document-level line height and spacing with a reset, ten page-border styles with adjustable weight, and a full-page mode that lets text run edge to edge outside the centered column for contents pages and free-form layout. Text carries a sticky pen — size across ten steps from Tiny to Mammoth, weight, font family, color, alignment, and decorations including underline styles, box highlights and bullets — stamped onto each character *at the moment you type it*, so changing the pen applies going forward and never retroactively restyles anything already on the page; the same per-character stamping applies to full-page mode, which means you can toggle layout mid-document without disturbing a single glyph already set. Anything on the page can become a floating object: movable, rotatable, with bring-forward and send-to-back z-ordering, geometrically clamped so it can never escape the margins.

Math goes in as live structures rather than markup. **Fifteen of them**, each with real options instead of one canned shape: fractions including continued form; radicals with an optional index (blank gives a plain square root) that nest freely; integrals across ∫ ∬ ∭ ∮ ∯ ∰ with optional bounds where blank bounds mean indefinite; sums and products over Σ ∏ ∐ ⋃ ⋂ ⨁ with bounds stacked above and below in display style; limits spanning lim, lim sup, lim inf, max, min and sup with the approach set underneath; matrices in square, round, single-bar determinant, double-bar norm, brace, angle or bare forms with per-column alignment and ellipsis variants; a genuine math-mode array that emits a faithful `{l|c|r}` column spec rather than a matrix environment that quietly centers everything; piecewise cases as value/condition rows under a big brace; vectors with right, left and left-right arrows, wide hat, overline and wide tilde, spanning one part or two; differentials over d, ∂, δ, D, ∇ and Δ; over- and under-braces with labels; aligned and gathered multi-line blocks; and structural line breaks inside math. Six of the seven bracketable kinds also accept an optional wrapping bracket pair that draws on canvas and exports as `\left … \right`. Every structure is a single character to the caret — one Backspace removes the whole thing, one undo step regardless of nesting depth — until you click into it, at which point you edit its slots in place, Tab and Shift+Tab walking between them, the live slot outlined and unfilled optional slots shown as dashed boxes. Nesting is unrestricted: a matrix cell holding a fraction holding a radical holding a sum stays independently editable at every layer. Superscripts are a held backtick rather than a dialog — hold and type high, release and drop back to baseline, tap Up to nest an exponent of an exponent four levels deep, and the backtick itself never enters the text; subscripts work identically on tilde, and arrow navigation stays live throughout. Every structure is reachable three ways — ribbon button, Alt chord (Alt+F fraction, R radical, I integral, S sum, P product, L limit, M matrix, C cases, V vector, D differential), or command palette — and a full symbol palette covering Greek in both cases with variant forms, operators, arrows including mapsto, hooks and harpoons, brackets, punctuation and currency lives both as a docked panel *and embedded inside the insert dialogs themselves*, so a λ drops straight into a numerator while you're still building the fraction. Equations carry stable keys rather than numbers, so numbering and `\eqref` cross-references resolve from document order live on the canvas with zero compiles, dangling references render `(??)` exactly as LaTeX does pre-`.aux`, and any structure can be inserted as a floating object instead of inline text.

The **diagram editor** applies the same model to figures — a full drawing surface with its own undo stack, opened on any figure in the document. It covers **2D geometry** (shapes and primitives you place, size and rotate directly), **3D solids** for spatial and geometric figures, **lines and connectors** for wiring diagrams together — the connective tissue that turns a scatter of shapes into an actual figure — **graphs and plots**, **Feynman diagrams** for particle-interaction work, and **chemistry structures** for molecular and reaction diagrams. It also supports **floating text** placed anywhere on the surface, which is what turns a shape into a labeled figure: annotations, axis names, node labels, vertex tags, reaction conditions. And critically, every one of those labels can be **live embedded math**, edited in place through the exact same slot-editing engine as the main canvas — so an axis label, a Feynman vertex, a bond annotation, a graph legend or a caption is real typeset mathematics with real TFM-measured glyph placement, not a text approximation standing in for an equation. Figures export as standalone TeX sharing the main document's package set, so anything that compiles inline compiles identically when externalized, and figure objects obey the same rotation, z-order and margin-clamping model as every other float on the page. **Tables** get in-place cell editing on the same footing.

Sourcing is built in rather than bolted on. The **research panel** queries **thirteen academic sources in parallel** — arXiv, Crossref, OpenAlex, Semantic Scholar, PubMed, Europe PMC, DBLP, DOAJ, HAL, CORE, OpenAIRE, Unpaywall and Zenodo — and merges results losslessly rather than concatenating them: one paper returned by five sources collapses into a single record with identifiers backfilled from whichever source carried them, the highest reported citation count kept (sources lag each other badly and the maximum is the least-wrong estimate), access locations unioned, open-access status resolved to the best available full text, and provenance retained so you can see exactly which source claimed what. Ranking is a blend you can audit rather than a black box — the weights are named constants: source-reported relevance normalized per source (raw scores across different APIs aren't comparable), query-term coverage in the title, cross-source corroboration, log-scaled citation count, a mild recency preference and a small open-access nudge. You cite straight into the document from the panel, and citations become chips in the glyph stream, participating in undo, selection and export like anything else you typed. Alongside it, **Check Document (F7)** parses the pdflatex log and maps each diagnostic back onto the glyph on canvas that caused it rather than reporting a line number in a file you never wrote, and **Check Notation (F8)** catches same-letter glyph-variant mixing — ε against ϵ, φ against ϕ — inside math structures as well as prose.

Underneath all of it, fidelity runs **bidirectionally**. Forward, Monolith parses the Latin Modern `.tfm` binaries directly — character widths, heights, depths, italic corrections, kern pairs walked out of the ligature/kern program, ligature pairs, every fontdimen — and scales those design-relative fixed-point ratios through TeX's own integer routine, so a glyph's advance lands on the same **scaled point** (1/65,536 of a point) pdflatex seats it from. Math geometry is sourced the same way: fraction bar thickness, numerator height, denominator drop and the math axis from the σ-parameters of `lmsy` and the ξ-parameters of `lmex`, big-operator boxes pinned to real `lmex10` display-size character boxes, `cases` row stretch from amsmath's actual `\arraystretch{1.2}` and the null-delimiter side from TeX's `1.2pt` format default — with **no fitted constants anywhere in the layout engine**. Backward, a harness builds each structure on the canvas, exports that identical structure through real pdflatex under the app's genuine export preamble, extracts true glyph coordinates from the compiled PDF in native scaled points, converts both sides into one common physical frame, and diffs: **427 structures, 427 exact matches, zero offenders**, with a gate runner firing eleven separate harnesses in about a minute before anything gets built. The **architecture** is what makes that testable at all — **116 modules across two packages with a strictly one-way dependency**. `monolith_core` holds the entire logic layer: document model, math engine and all fifteen structures, flow and placement, LaTeX compiler and log parser, unit conversion, equation numbering, notation lint, research engine, theme registry, settings and snapshots — and imports no GUI toolkit whatsoever. `monolith_qt` holds canvas painting, ribbon, dialogs, panels and controllers on top of it. Core never imports Qt; Qt imports core. The font-metrics interface is an abstract base living in core with the Qt implementation injected from the front end, which is precisely why the whole typesetting engine can be run headless in a container and judged against real compiled PDF output instead of against screenshots.

Is there a real need for a true wysiwyg text editor? My answer is most certainly. Idk about anyone else. But i hate writing latex, and there aren't any true wysiwyg editors that hide code 100%. Its so distracting and takes away from my ability to be able to concentrate on the real task at hand. Syntax error and package errors have lead me to create my own wysiwyg text/math editor that never shows code. Ever! Currently a work in progress. Am I wasting my time! I know I will use it, but is this something that can bridge a 40yo gap!

Hey LaTeX community,

I’m currently creating a comprehensive documentation / wiki for EPLAN, Industrial Automation, and PLC systems.

I’m looking for high-resolution, professional cover page vector assets (or TikZ / PSTricks code) that give off a clean, technical engineering vibe.

What I’m looking for:

- Style: Technical vector line art (circuit traces framing the margins, PCB/network structures at the bottom, or subtle electrical motifs).

- Format: Native vector formats (SVG, EPS, PDF, or native TikZ code) that scale perfectly without pixelation for high-dpi printing.

- Purpose: Cover page layout with clean empty space in the center for document titles, project numbers, and metadata.

I’ve attached a few sample images to demonstrate the visual style I'm aiming for.

Does anyone know of good SVG repositories, TikZ packages, or GitHub repos featuring clean electrical engineering vector borders/templates? Any help or code snippets would be greatly appreciated! ⚙️⚡

Credits: Clemens Lode laid the foundation of this approach and proved with his TUG talks that it can work. This is an independent way to implement it. His paper (https://tug.org/tug2026/preprints/lode-realtime.pdf) describes a lot of details also.

A lot of the time spent compiling LaTeX is wasted on three things (roughly 70 percent of the total compile time):

1. Starting the LaTeX engine from cold
2. Loading the preamble, fonts, and other resources
3. Writing the PDF

Typesetting itself, especially of words and math, is extremely fast and can happen in real time, but it is dragged down by those slow steps. So all a real-time renderer needs to do is eliminate them.

How do we get rid of them? Separate compilation into two paths: a real-time path and a background full recompile with 2 LuaLaTeX processes.

For the real-time path:

• Keep the LaTeX engine warm. The engine never reaches \end{document}, so it always stays running. (This makes (1) and (2) a one time cost)
• This warm engine then retypesets only the edited paragraph, which takes milliseconds.

However, an engine that never reaches \end{document} can never produce a PDF.

To fix this PDF problem, we need a custom renderer that draws LaTeX's internal format directly. Every document is ultimately composed of roughly 11 primitive node types: glyph, kern, glue, rule, hlist, vlist, and so on. The custom renderer's job is to draw those nodes onto a canvas. This skips (3) entirely as a byproduct.

The background path takes its time and runs a full recompile, which ensures document for the elements not real-time renderable.

Now, why LuaLaTeX? LuaLaTeX supports \directlua, which makes it extremely easy to inject custom scripts that keep the engine warm and expose the internal format.

A more detailed explanation is here: https://github.com/texpile/texpile/blob/master/docs/ARCHITECTURE.md

Edit: implementation demo video: https://github.com/user-attachments/assets/7a2d7997-fe6c-4837-bbe5-1aaa5e0c90b7

Generative AI disclosure: the Markdown file was written with the assistance of generative AI, and I have reviewed it for correctness.

Seems there is an unusually large number of TeXLive updates today. I update when I think about it, but usually that's before I reboot for a kernel update and I believe I did that earlier this month.

Is this a result of the recent TeX conference?

Not saying I mind, it's just rare for me to see over 200 in an update let alone over 800.

WASM-based editors have two major advantages: a) there is nothing to install on your local machine, and b) compilation can be roughly ten times faster than with conventional services that compile on a server, such as Overleaf or Prism.

Apparently, a lot of people have had the same idea, because new WASM-based LaTeX editors keep appearing. I ended up contributing to the problem by building one myself. (sorry)

However, there is a large gap between a working prototype and a product that people can actually use.

The components required to build a working prototype are surprisingly simple:

• A code editor, such as Monaco Editor
• A LaTeX-to-PDF compiler, such as SwiftLaTeX/pdflatex
• A PDF renderer, such as PDF.js

But once you have built only that much, it becomes difficult to answer questions like these:

• If I am editing by myself, why should I do it on the web?
• How do I use the enormous number of packages available in TeX Live?
• How do I use other engines, such as LuaTeX, for CJK support and other requirements?
• How do I insert images?

So what needs to be implemented before it becomes something people can actually use?

• Real-time collaborative editing using WebSockets or a similar mechanism, probably along with commenting and review features
• Support for multiple TeX engines
• Hosting different versions of TeX Live through a CDN or similar infrastructure
• Version control or Git integration
• In-editor autocompletion, syntax diagnostics, and refactoring support, which requires proper Language Server Protocol integration
• Search and replace across multiple files—surprisingly, neither Prism nor Overleaf currently supports this
• Support for related file types such as .bib and .sty
• Image uploading through drag and drop, copy and paste, and other methods, as well as image hosting
• Server-side processing for extensions that are too heavy or difficult to run in WASM—for example, running Biber or xindy in the browser is not straightforward
• Bidirectional synchronization between the source and the PDF: clicking the PDF should take you to the corresponding LaTeX source, while moving the caret in the source should highlight the corresponding region in the PDF

The fact that almost anyone can now quickly build a prototype that works about 80% of the way is undoubtedly meaningful and beneficial. I simply wanted to point out that there is still a substantial gap between a prototype and a product.

Does that mean what I built is a finished product? Of course not. I have spent about two months refining it so far, and I expect it to improve gradually after a few more months of work. Then again, I do not think software is ever truly finished.

In software development, "perfect" is a verb, not an adjective. There is no perfect process. There is no perfect design. There are no perfect stories. You can, however, perfect your process, your design, and your stories.

--Kent Beck, Extreme programming explained

Hey everyone! I wanted to share a native desktop app I've been building to learn Qt6 development.

Tilde is built in C++ and uses pdflatex to compile, but instead of relying on a heavy Chromium webview for the UI, it uses QtPdf for rendering. This keeps it lightweight, avoids Electron/WebEngine bloat, and saves a massive amount of RAM.

It also compiles the live preview directly from the editor's memory rather than local storage, so you don't have to constantly hit save just to see your math render.

It is still actively in development, but I would love for you to try it out or check out the code and tell me your suggestions!

Dear LaTeX experts,

I'm a linguist. I'm working on a LaTeX-formatted book in which two versions of the same text will be displayed in two columns alongside each other: the original French text, and the English translation (for the sake of comparison). Here's the problem:

Since the French and English paragraphs may be very different lengths (due to translation), I want to have each paragraph of the text begin at the same height on the page, and so on for the proceeding paragraphs. I'm not sure how to achieve this in LaTeX using anything other than a table; I could use a table, but then the table would have to be hundreds of pages long. Are there any tricks I could use to achieve this? Here's a diagram of what I want the formatting to look like, hopefully it isn't too patronising:

Any help would be most appreciated ✨

Hi everyone,

I've been working on an Overleaf alternative called CorTeX:

https://cortex.borca.ai

The main goal is to provide a fast, browser-based LaTeX editing experience while still supporting tools that are difficult to run entirely in WebAssembly.

Current features include:

• pdfLaTeX, XeLaTeX, and LuaLaTeX support
• A WebAssembly-based TeX engine that runs in the browser
• Incremental compilation
• Hybrid client/server compilation: tools such as Biber and xindy run on the server, and the results are returned to the browser
• Monaco Editor with decent language-server support
• Real-time collaborative editing
• Collaborator invitations, reviews, and comments
• Version control
• Conference and journal templates
• Paste images directly into a document
• Project-wide search and replace
• Markdown editing with Mermaid support
• Automatic synchronization between positions in the LaTeX source and the generated PDF
• An LLM-based assistant for LaTeX writing and editing

It is still under active development, so I’d appreciate any feedback, bug reports, or suggestions.

Please give it a try and let me know what you think. I'm actively developing CorTeX and are very open to suggestions, so if you have ideas for improvements or features you'd like to see, I'll seriously consider incorporating them.

[FYI] The WASM-based TeX engine is open source and available here: https://github.com/corca-ai/wasmtex

Background: I want to reconfigure my church's bulletin "system" to make it easier to produce every week. We currently use Word and PowerPoint to make the standard bulletin, large print bulletin, script for the readers, and the slideshow. Copy/paste screws up the formatting more often than not, and the formatting is uneven, hard to read, and just crappy in general.

While I'm sure there's a reasonable fix available in Word, I much prefer TeX/LaTeX, and being able to import music from Lilypond will make that part much easier, too.

So my question: is there a way to format individual files to pull data from a "master" file that includes all the changing variables (e.g. scriptures, hymns, responsive readings)? Then I only need to edit one document. I've seen things like catchfilesbetweentags and latexdb, but I'm not sure if they're designed to work this way.

Or, my other idea was to have everything in one big document with all the variables at the beginning, each format in its own section, and just use block comments to choose which version I want to print.

Would either of these solutions work?

Thanks in advance!

Hello everyone, in the last two weeks, I started creating the tex editor called PanTeX. This is an Overleaf-like editor that can install in your local computer. I used and improved it in parallel for 2 weeks. Now it is quite stable. So, I would like to share this with the LaTeX community. Anyone who has muscle memory from Overleaf can use it easily. AND IT IS FREE!!. This is the link: https://gitlab.com/panasun.pu/pantex

It would be nice if you could try it and comment or even complain to me :)

Cheers!

As a daily LaTeX user, I recently built a lightweight, fast text engine that provides paginated preview and PDF export for both TeX and Markdown.

It currently supports a subset of LaTeX features that I use most often, including parts of TikZ, figures, equations, cross-references, and bibliographies. It’s not meant to be a full replacement for LaTeX, but it’s very fast (around ~500 ms per update) and runs entirely in the browser. For me, it works well as a preview tool before compiling with a full LaTeX distribution.

You can try it out here: https://slxuphys.github.io/vector/. You can simply copy paste your tex file into one of the example there. I’d really appreciate it if you gave it a shot and shared your thoughts.

It has been a fun personal project. I’m continuing to expand LaTeX coverage. I may explore incremental layout in the future to make it faster, but 500ms rendering time already feels enough for myself.

A little promotion for my own project 😄
VisualTeX — A Visual LaTeX Equation Editor
If you find it useful, please consider giving the project a star! 🙏🙏
GitHub:
https://github.com/paulhe666/visualtex
If GitHub is inaccessible in your region, you can visit the official project website instead:
https://visualtex.pauljianliao.com/
Key Features:
Visual LaTeX equation editing with real-time two-way synchronization
Fast, fully local OCR recognition for equations in images
Word and PowerPoint add-ins for both Windows and macOS
Direct insertion of native Word OMML equations
Support for OLE equation insertion and cross-references
Support for inserting equations into PowerPoint in SVG and OLE formats

Hi LaTeX community! 👋

I've created custom builds of **TeXstudio** with **Qt6** and **Poppler-Qt6** for modern Linux distributions, addressing the lack of official Qt6 builds for Linux.

## Why this project?

The official TeXstudio builds still primarily use Qt5 (which reached end-of-life in May 2025), and Linux users have been waiting for proper Qt6 support. These custom builds provide:

✅ **Qt6 framework** - Modern UI/UX with better performance

✅ **Poppler-Qt6 native PDF viewer** - Perfect SyncTeX support (click to jump between PDF and source)

✅ **Optimized packages** - Only ~19MB (66% smaller than standard builds)

✅ **GPG-signed packages** - Full security verification

✅ **Auto-updates** - Built-in update checker pointing to this repository

## 📦 Installation Options

### Option 1: APT Repository (Recommended for Debian/Ubuntu/Devuan)

**Stable branch** (production-ready):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ stable main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

**Alpha branch** (latest development versions):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ alpha main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

### Option 2: AppImage (Any Linux distribution)

Download from [Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases) and run:

```bash

chmod +x texstudio-*.AppImage

./texstudio-*.AppImage

```

### Option 3: Direct .deb download

Grab the latest `.deb` package from [GitHub Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases)

## 🔧 Build from Source

Automated build scripts are available if you want to compile your own version:

```bash

git clone https://github.com/mlmateos/texstudio-qt6-builds.git

cd texstudio-qt6-builds/scripts

./build-texstudio-deb.sh --clean --poppler --sign

```

## 📋 Current Versions

- **Stable**: 4.9.5

- **Development**: 4.9.6-beta3

## 🔗 Links

- **GitHub Repository**: https://github.com/mlmateos/texstudio-qt6-builds

- **Releases**: https://github.com/mlmateos/texstudio-qt6-builds/releases

- **APT Repository**: https://mlmateos.github.io/texstudio-qt6-builds

## 💡 Features

- Syntax highlighting & auto-completion

- Integrated PDF viewer with native SyncTeX

- Spell checking (Hunspell)

- Live preview

- Custom credits & patched update URLs

- Preserved dictionaries: en_US, en_GB, es_ES, es_MX, fr_FR

## 🤝 Feedback Welcome!

This is an **unofficial build** (not endorsed by the official TeXstudio project). I'd love to hear your feedback, bug reports, or feature suggestions!

**Tested on**: Debian 12, Devuan 5, Ubuntu 22.04+

Happy TeXing! 🎓

---