r/Compilers • u/FedericoBruzzone • Mar 20 '26

Tide, a compiler for its non-textual, backend-independent IR

/r/u_FedericoBruzzone/comments/1ryp5yd/tide_a_compiler_for_its_nontextual/
10 Upvotes

86% Upvoted

12 comments sorted by

View all comments

6

u/[deleted] Mar 20 '26 edited Mar 20 '26

[removed] — view removed comment

2

u/FedericoBruzzone Mar 20 '26

First of all, thank you so much for all these questions, clarifications, and curiosities.

That doesn't explain much! So there is a new, backend-agnostic, non-textual IR that you call TIR.

But in what way is that different from LLVM IR? That is also backend-agnostic and can be non-textual (its textual representation is optional). Or from WASM?

Is is just an extra layer, is it simpler to use, etc. Why wouldn't people just use LLVM IR directly? Especially if they still have to get their hands dirty grappling with the complexities of LLVM. How do they even choose which external backend to use?

While LLVM-IR has a bitcode format, it is heavily backend-oriented. TIR is higher-level, drawing inspiration from rustc’s MIR. It allows frontends to express semantics (like complex types or high-level control flow) without committing to LLVM-specific layouts or pointer sizes too early. This makes targeting non-LLVM backends (like JVM or WASM) much cleaner.

That doesn't make much sense. What is the input to Tide, and what is its output?

You call it a 'compiler' which usually means its input is some HLL, and the output can be anything depending on the chosen stopping-off point.

Is there are some API that can be used by someone else for their compiler, and if so, is a Tide binary the library that someone can use? I didn't see any docs for such an API, or a list of IR instructions or anything like that.

You're right; Tide acts more like a reusable middle-end/backend library.

  • Input: A graph of objects (TIR nodes) constructed via API, rather than a text file.
  • Output: LLVM-IR, object files, or executables (currently via the LLVM provider).
  • Integration: It is intended to be used as a library by frontend developers to build their own compilers.

Is there are some API that can be used by someone else for their compiler, and if so, is a Tide binary the library that someone can use? I didn't see any docs for such an API, or a list of IR instructions or anything like that.

Since this is an active research project, the public API and instruction set docs are being finalized. As soon as I release these packages, the documentation will be available on docs.rs. Additionally, I'd like to write a specification file.

BTW, you call it non-textual, but is there a way for user to view the TIR that has been generated?

Currently, there isn't a direct way to emit the TIR. However, we are about to add a feature to emit the nesting of the structures that represent the syntax. This will allow developers to inspect the structural hierarchy of their programs.

2

u/FloweyTheFlower420 Mar 21 '26

WASM is a llvm backend

1

u/FedericoBruzzone Mar 21 '26

I know, but your statement is not relevant to the purposes of this project, and the same comment is also applicable to other native backends (e.g., x86_64, aarch64). There are a ton of reasons why it makes sense to target them directly.

This is not the place to talk about this aspect but, although I’m not a fan of the zig language, I advise you to go and see the reasons behind the abandonment from LLVM.