HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
FluxML
Zygote.jl
Julia2018–2023
FluxML / Zygote.jl

Zygote.jl

21st century AD

17Distinct people
23Mentions
0Explicit recommenders
1.6KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

21st century AD

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 12:01:57 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year23 dated mentions

Observed mentions: 2018-10-22 16:04:07 UTC to 2023-12-04 14:08:04 UTC.

02468102018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 4 mentions; 2 submissions, 2 comments20182019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 5 mentions; 0 submissions, 5 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2023

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC422
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC909
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC303
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC505
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC000
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC202

What Hacker News says

5 sources
> in this sense hosted languages are always a front-end. common lisp is not this Even self-hosted languages are front-ends for assemblers and microcode. What actually matters is being able to have arbitrary control over how code is executed. Julia has this in spades. Julia has it's own intermediate representations where you can write custom compiler passes and intercept and modify whatever you like (in pure julia). You can think of these tools as being like macros, except instead of lexical extent they have a completely dynamic extent. With these passes, you can arbitrarily change the meaning of any code recursively. E.g. You could define an execution context where multiplication and addition have swapped meanings, or you could locate every if-else statement in the entire callstack of a program and switch the if clause with the else claus
Read the rest
e. And again, this is not limited to the lexical extent of a macro, and it does not disable compilation. It is instead a programmable step in compilation. A classic example of this would be Zygote.jl [1] which takes a program and recursively generates code to that would give the derivative of that program. Doing this requires you to modify literally every function call in the callstack, and you can do this all in pure julia without ever knowing a lick of LLVM. Granted, there is something ideologically appealing about the idea of a self-hosted langauge. I'm just arguing that on a practical level, the compiler tools allow total control over code execution without changing languages, just as you'd get in a self-hosted language. [1] https://github.com/FluxML/Zygote.jl
In Why Lisp? (2015)
Thanks again. Like you said it is fun to dream (ask the "Scheme Machine" guys sometime about how they would go about it now), but practically with technology like Julia's Zygote: https://github.com/FluxML/Zygote.jl the efficiency of autodiff might be similar to that of an opcode anyway. So, how did DEC do on the Alpha processor? I always heard good things about it--IIRC (I didn't) it was ~~based~~ to replace the VAX, but 64 bit. I learned PDP-11 assembler at RPI, during their college program for high school students in about 1984. We hand assembled code and really got to know the architecture.
In The KimKlone Microcomputer
Arborist.jl https://github.com/oxinabox/Arborist.jl/ It implements one of the more advanced tricks in JuliaLang. Which is the concept behind Cassette.jl (https://github.com/jrevels/Cassette.jl) and IRTools.jl (https://github.com/MikeInnes/IRTools.jl). which is this notion of a recursive source code tranformation. This is the thing where you tranform code (kind of like a macro but not lexically scoped), including tranforming all function calls to also tranform their code. It's super powerful For example Zygote.jl (https://github.com/FluxML/Zygote.jl) implements reverse mode automatic differentiation, by defining a function that is a generated transformation of the function being differentiated. MagneticReadHead.jl (https://github.com/oxinabox/MagneticReadHead.jl/) implements a debugger by defining a function that has been transformed to in
Read the rest
clude debugger interupts. This stuff also has a bunch of use for probabalistic programming languages etc. The thing is Cassette and IRTools implement this at the lowered code level. It runs on the SSA-form IR. This IR was never really designed for the user to write it. Though IRTools does a noble attempt to make it nice. Arborist instead runs at the Abstract Syntax Tree (AST) level. Just like macros. This is designed to be written and manipulated by users. Users do that all the time by writing macros. I haven't touched it in a while (apparently 2 years). Largely because AFAICT it's not useful outside of pedagogical purposes. AST is not actually that nice for any program tranforms i want to do, since there are so many ways to write the same thing. E.g. different kinds of loops and branches, where as in SSA form IR they all look the same. Probably could be made to work, but i just don't really have a usecase that I can't do easier on IR. (probably people who haven't been deep into IR on the other hand would think of some) There are a bunch of edge cases where it crashes still, for things that are not allowed to appear in generated code. It wouldn't be too hard to make it work though, not really. Particularly since we now have tools like https://github.com/SciML/RuntimeGeneratedFunctions.jl https://github.com/JuliaStaging/GeneralizedGenerated.jl
In Ask HN: Show me your half baked project

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.