maxloh

Background of the project:

Tectonic is forked from the XeTeX TeX engine. However, the build process for XeTeX (and all other mainstream TeX engines) is extremely baroque:

1. The original Knuth sources are written in a language called WEB (which is basically used by nobody else)

2. Those sources are then patched with a series of “change files” due to restrictions on distributing modified sources

3. These patched files are then converted to the Pascal language using some custom processing scripts

4. That Pascal code is then converted to C code using additional custom tools

5. Those C files are then compiled against a set of extension files and libraries written natively in C and C++

One of the big motivators for the launch of the Tectonic project was to break out of this ridiculously unwelcoming development process. Tectonic is based on the C/C++ files that emerge from the XeTeX build process, and is gradually translating that code to modern Rust.

While the core TeX architecture and XeTeX are largely stable, they do, however, evolve with time. This repository recreates the final XeTeX C/C++ files from their source, so that modifications can be ported into the main Tectonic codebase.

https://github.com/tectonic-typesetting/tectonic-staging/blo...

I just tried using Fable 5 with Claude Code by asking it to create a LaTeX document for me.

There is no LaTeX compiler installed on my machine. It seems that Fable 5 is smart enough to download a compiler engine for me, and it kindly runs that remote binary without asking me first :)

  Support files are in place. No LaTeX compiler on PATH — let me check for a MiKTeX/TeX Live install elsewhere before writing the deck.
  
  Ran 2 commands
  
  Ran Search common LaTeX install locations
  Bash
  ls "/c/Program Files/MiKTeX"*/miktex/bin/x64 2>/dev/null | head -5; ls "/c/Users/[retracted]/AppData/Local/Programs/MiKTeX/miktex/bin/x64" 2>/dev/null | head -5; ls /c/texlive/*/bin/windows 2>/dev/null | head -5; ls /d/texlive /d/"Program Files"/MiKTeX 2>/dev/null | head; which tectonic latexmk 2>/dev/null; echo done
  done
  
  Ran Download portable Tectonic LaTeX engine
  Bash
  cd /tmp && curl -sL -o tectonic.zip "https://github.com/tectonic-typesetting/tectonic/releases/download/tectonic%400.15.0/tectonic-0.15.0-x86_64-pc-windows-msvc.zip" && unzip -o tectonic.zip && ./tectonic.exe --version
  Archive:  tectonic.zip
  Created by Cranko
    inflating: tectonic.exe            
  tectonic 0.15.0Tectonic 0.15.0
  
  Tectonic works. Now writing the bibliography and the full deck.

Opus 4.8 would just proceed without a compiler.

  Ran a command, used a tool

  Ran Check for LaTeX toolchain availability

  Bash
  cd "C:/Users/Mon/Downloads/Technical Writing" && for c in pdflatex xelatex latexmk bibtex; do printf "%s: " "$c"; command -v $c || echo "NOT FOUND"; done
  pdflatex: NOT FOUND
  xelatex: NOT FOUND
  latexmk: NOT FOUND
  bibtex: NOT FOUND
  
  Used PowerShell
  command: $cmds = @('pdflatex','xelatex','lualatex','latexmk','bibtex','miktex','tlmgr'); foreach ($c in $cmds) { $p = Get-Command $c -ErrorAction SilentlyContinue; if ($p) { "{0}: {1}" -f $c, $p.Source } else { "{0}: NOT FOUND" -f $c } }
  description: Check for LaTeX engines on Windows PATH
  pdflatex: NOT FOUND
  xelatex: NOT FOUND
  lualatex: NOT FOUND
  latexmk: NOT FOUND
  bibtex: NOT FOUND
  miktex: NOT FOUND
  tlmgr: NOT FOUND

  No LaTeX engine is installed locally, so I can't produce a PDF here — I did a careful structural review against the two prior (working) decks instead. The deck is written to disk and mirrors their template exactly. Here is the deliverable.

Will you open source it?

The generation speed in the demo video is crazy, to say the least, and completely beyond my impressions of LLMs.

The Xiaomi team really brought something to the table.

I don't know why this was flagged, but you are right.

Google Docs [1] and OnlyOffice [2] also employ the canvas method to render office documents, and have found it reliable and consistent among different browsers.

[1]: https://workspaceupdates.googleblog.com/2021/05/Google-Docs-...

[2]: https://helpcenter.onlyoffice.com/faq/technology.aspx

> ...this does not appear to output highlightable text

Yeah, it does.

https://ooxml.silurus.dev/storybook/?path=/story/docxviewer-...

I've heard that the same file can render differently in MS Word across different machines and OSs. So, that won’t help either.

That phrasing was taken from their website: https://ooxml.silurus.dev/

Yeah. That would be great!

Not really. That means you give your customers the code to use under your current restrictions, and after a specific period, they can use it under the open-source license of your choice as well.

Could you consider Delayed Open Source Publication (DOSP) [1]? With that, you make the source code open-source after a specific period of time (such as 5 years).

This way, your customers still get the source code and can use it freely, but you don't have to worry about competition. By the time anyone could use it to compete with you, they would be using an ancient version of your software. The BUSL (Business Source License) by MariaDB is a battle-tested license designed for exactly this use case.

[1]: https://opensource.org/delayed-open-source-publication

I think the problem lies in the fundamental design of VS Code extensions in general. They are essentially Node.js apps with full access to built-in modules, including fs. If the corresponding VS Code instance is launched with your user privileges, extensions can technically read files in ~/.ssh.

It is not safe in the sense that for every extension you install, you are essentially installing a new Node.js app with all its bundled dependencies. Even if you trust the publisher, I am sure there are many holes to exploit.

It takes a few years for vendors to support hardware decoding for a new standard, so we won't see it in widespread use anytime soon.

OpenRouter is merely only a proxy. They also host some open-weight models

Claude’s reasoning models really impress me as a Gemini user, both in coding tasks and in creative writing for my social science courses.

They are capable of thinking at least 10x longer than Gemini. They can deliberate for five minutes continuously before providing a final, accurate response.

I am currently using the generous free tier of Gemini, but if Gemini offered a similar capability in its paid tier, Google could use better marketing. They should have used a different name to distinguish their premium-only offering.

Anthropic also resets my usage limits (I am in the Pro plan). That's very kind of them :)

No. It is 100% open source, not even open core like GitLab.

I think the reason is that it has no public-facing instance with unlimited CI usage.

Maybe this statement actually holds in reverse?

Quoting vbernat's comment on Lobsters:

  systemd was a "gift" for people running alternative desktop systems. Previously, many services were bundled with GNOME and you had to go through many hops to use them on a non-GNOME desktop (for example, GNOME Power Manager). systemd replaced many of these GNOME-only piece of software that were constantly breaking when you tried to use them outside of GNOME. Alternative desktop environments didn't need to write their own version of system-related tools.
  
  So, while this may be seen as centralization, I don't think we would have seen so many desktop environments without systemd. In the past (15+ years), systems were simpler and there was not many things to abstract.

https://lobste.rs/s/gfbpgq/flatpak_will_depend_on_systemd#c_...

50

It could be an attack surface. Maybe one day, when we find a chatbot online, we could let it guess a random number repeatedly, then accurately infer the underlying model based on the resulting distribution.

I don't know about the author's background, but there is now a generation of non-native programmers who learned to write English by using LLMs for corrections (yeah including this comment).

The irony is that studies show LLM detectors have a much higher false-positive rate for non-native speakers [1]. If most of what you read stems from LLMs, you end up writing like an LLM.

[1]: https://hai.stanford.edu/news/ai-detectors-biased-against-no...

I think the problem is that C++ is a poorly designed language with a fundamentally flawed development process.

Instead of letting compiler implementers decide which features to add and how to implement them, C++ employs a standards-first, top-down approach. Features are often defined by committee members who may not use modern C++ in their daily workflows, leaving it entirely up to the individual implementations to catch up.

Some features were standardized back in 2023, yet not a single implementation supports them in 2026.

https://en.cppreference.com/cpp/compiler_support

https://cppstat.dev/

I understand their decision. How could the maintainers understand their codebase if most of it was not directly written by them?

It is impossible to review the entire rewritten codebase. There are just too many lines of code, 1 million lines to be exact [1].

[1]: https://github.com/oven-sh/bun/pull/30412

There is actually a concept called Fitts' Law that just describes what you said.

When tabs are placed against the very top edge of the screen, the top edge effectively acts as a target with infinite height (Y-axis), making it very easy to reach.

Apple and Microsoft both apply this concept in their OS, just to different elements (close button or menu bar).

https://en.wikipedia.org/wiki/Fitts%27s_law

> Source-available under the Functional Source License v1.1 (FSL-1.1-MIT). Free for any non-competing use; converts to the MIT license on the tenth anniversary of each release. See LICENSE.

You should not use the FSL name if you change the date of the license switch, which is originally set to the second anniversary. If you want to change that duration, you should use a different name to avoid confusion.

Sentry intended for the FSL to be specific rather than general. The company's Deputy General Counsel stated:

> TLDR, FSL is narrow in scope for a reason.

> You're free to create your own license based on the FSL with AGPL as the change license if you rename it so that it isn't confusingly similar.

https://github.com/getsentry/fsl.software/issues/53#issuecom...

Claude's workflows might become good training data for LLMs: https://github.com/oven-sh/bun/tree/23427db/.claude/workflow...

The correct phrasing would be "Toybox is... a BusyBox with a more permissive license." BusyBox started first.

  Toybox was started in early 2006 by Rob Landley after he ended his BusyBox maintainership due to a dispute with Bruce Perens, the original creator of BusyBox.[1]

[1]: https://en.wikipedia.org/wiki/Toybox

I actually like GitLab's new UI, but their frontend is far too laggy given its complexity, especially since most of their pages are actually server-side rendered. It doesn't help that they use a weird combination of Vue 2 and jQuery in their codebase.

I think that as a corporation promoting the use of AI, they should actually be AI users themselves. They should just rewrite that laggy UI in Svelte, Solid, or even vanilla JS. Any of those would work.

I think it was an afterthought in the design. CI cache should be scoped per-user, or at least per-group.

If a workflow run by a maintainer (with access to secrets) can pull a cache tarball uploaded by a random user on GitHub, then it’s a security black hole. More incidents like this are inevitable.

Is there even breaking change in Rust after 1.0?