8 ms·

The Red Programming Language

213 points by hotpocket777 1y ago

justin66 1y ago
I figured they were cooked when they started doing weird cryptocurrency-related stuff. I really hope they get to their 1.0 release someday.
- 7thaccount 1y ago
  Same. I was regularly following it until they started talking about an ICO and began focusing too much on making a dialect for block chain stuff. The idea between having the red system language, regular scripting language, cross platform gui, and native executables was really cool though. I remember being interested back in ~2015, so my question is...what's going on as it's been a decade. I know the project is crazy ambitious of course, but how close are we to where this is at a stage where most would consider it production worthy.
  - troupo 1y ago
    IIRC think their original roadmap had 1.0 around 2020. And that was going to include everything, including async written from scratch in a language where nothing was made for async. Then the roadmap slipped, and then never mentioned again. But I haven't looked at the language or discussions around it for a long while now. Edit: found some old discussion here. In 2018 they were at version 0.6.4 https://news.ycombinator.com/item?id=18864840 https://news.ycombinator.com/item?id=18864840 In 2025 they are at version 0.6.6: https://github.com/red/red/releases https://github.com/red/red/releases
    - LkpPo 1y ago
      For me, it even went off the rails before, when Nenad went to China because he was able to raise funds for the project. But he hadn't anticipated that he would be in charge and not the other way around. The situation seems to suit him perfectly. I don't think Red has any future at this point. In any case, the roadmap has always been stratospheric.
      - em-bee 1y ago
        can you elaborate what you mean by not anticipating that he would be in charge? btw, i met him in beijing while he was there.
        LkpPo 1y ago
        That he would not have been able to do what he hoped to do to meet other demands of his creditors. Pure speculation.
- therein 1y ago
  Interesting, that at least explains why this happens a little bit. https://i.imgur.com/a/phd4lVr https://i.imgur.com/a/phd4lVr
  - sph 1y ago
    Holy nanny state. The authors of a language have thought about using cryptocurrency, so it's flagged as a phishing and scam site? Literally 1984.
    - skywhopper 1y ago
      It gives you a way to proceed anyway, and is opt-in, and not run by any government. How is that “nanny state”? Also, given that it doesn’t torture and murder people, it’s not quite 1984 either.
    - goku12 1y ago
      It's a community maintained block list. You may be able to do something about it. So, not 1984 all the way.
    - justin66 1y ago
      That message was created by... the state?
kstrauser 1y ago
This is a successor to REBOL[0], designed by Carl Sassenrath[1] who designed the Amiga kernel. I've looked it a few times over the years. It's neat. I've never written a single line of it, though. [0]https://en.wikipedia.org/wiki/Rebol https://en.wikipedia.org/wiki/Rebol [1]https://en.wikipedia.org/wiki/Carl_Sassenrath https://en.wikipedia.org/wiki/Carl_Sassenrath
- dev_l1x_be 1y ago
  "In 1988, Sassenrath left Silicon Valley for the mountains of Ukiah valley, 2 hours north of San Francisco. From there he founded multimedia technology companies such as Pantaray, American Multimedia, and VideoStream. He also implemented the Logo programming language for the Amiga, managed the software OS development for CDTV, one of the first CD-ROM TV set-top boxes, and wrote the OS for Viscorp Ed, one of the first Internet TV set-top boxes." What a legend!
  - kstrauser 1y ago
    Right? And I think that's what keeps bringing me back to REBOL, and thus Red. They don't appeal to me on the face of them. Like, the code examples look interesting but in a "magical" kind of way that strikes a little bit of fear into my engineering heart. But with that kind of pedigree, I can't dismiss the ideas. If Sassenrath came up with it, I bet there's a kernel of awesomeness inside.
    - Izkata 1y ago
      I suspect a lot of the magic will fall away after realizing the block data structure (the square brackets) are pretty close to a Lisp list. And just like in Lisp, they're used for both code and data. One big difference is words are evaluated by default instead of just the first word in a list, so there's nowhere near as much nesting, and whenever an expression ends the next one can begin with no delimiter (but use newlines for legibility).
  - tejtm 1y ago
    pretty sure he finished out his post Rebol career with Roku
ConanRus 1y ago
32 bit only
- anta40 1y ago
  Which is a deal breaker for macOS users... unless they are still on Mojave.
ttoinou 1y ago
This is like the only programming language I could never learn. I just don't understand anything and I can't build any mental model of what's going on behind the hood
- almostgotcaught 1y ago
  it's lisp with square braces instead of parens (and then a whole bunch of other random things like a gui library in the standard library?)
  - TOGoS 1y ago
    The square brackets aren't really analogous to Lisp's parentheses; REBOL / RED use parentheses for the same purpose, if you need them. The square brackets are more like square brackets in Factor or Joy; they are 'quotations' around a list of words (or other syntactic structures; basically they make a list that is not evaluated immediately).
  - timbit42 1y ago
    It's actually more like Logo, which is Lisp with square brackets instead of parens and fixed arity. Sassenrath wrote Amiga Logo before starting REBOL.
- TOGoS 1y ago
  I wrote a paper on REBOL back in college. It is very interesting, but the syntax is definitely weird. You might think of the function call syntax as being sort of Forth-like, but with the tokens in reverse order. So like a Lisp, but without required parentheses. e.g. in the example send friend@rebol.com read http://www.cnn.com `read` knows that it takes one argument, and `send` knows that it takes two, so this ends up being grouped like (send friend@rebol.com (read http://www.cnn.com)) (which I think is valid syntax; that AST node is called a 'paren'). Weirdly, the language also has some infix operators, which seem a bit out-of-place to me. I have no idea how the 'parser'[1] works. [1] 'parsing' happens so late that it feels funny to call it that. The thing that knows how to treat an array as a representation of an evaluatable expression and evaluate it.
croemer 1y ago
The website looks like 2013 and much of the content is as well. There's a GitHub repo that I couldn't find from the website: https://github.com/red/red https://github.com/red/red
- worldsayshi 1y ago
  The repo seems to be alive and kicking.
- pabs3 1y ago
  The website links to GitHub with the usual logo, in the right hand column. The website has posts from 2025: https://www.red-lang.org/2025/04/multiple-monitors-support.html https://www.red-lang.org/2025/04/multiple-monitors-support.h... Unless you mean the theme, thats probably just a standard Google Blogger/Blogspot theme, which has been around for 25 years. https://en.wikipedia.org/wiki/Blogger_(service) https://en.wikipedia.org/wiki/Blogger_(service)
  - croemer 1y ago
    The mobile website is different than the desktop version, that's not very common anymore. There's no GitHub logo in the mobile version.
niek_pas 1y ago
I haven’t looked at this in detail, but it seems they confuse “human-friendly syntax” with “absence of (<[{“.
38 1y ago
red was terrible in 2018, and its terrible now - just tried to compile hello world and it takes 36 seconds https://github.com/red/red/issues/5615 https://github.com/red/red/issues/5615
- burnt-resistor 1y ago
  Go compiles massive codebases in that time. V can recompile itself probably 2-3x in that time. I don't take any new language seriously unless it's memory safe, free of UB, able to interoperate with what already exists including optional shared libraries (because static linking the world every time in everything is memory and disk wasteful), and assists formal proofs of correctness. Otherwise, what already exists seems preferable for serious use and hobbies can remain fun distractions.
  - 38 1y ago
    troll spotted
  - binary132 1y ago
    If a language can’t use shared objects at all, it’s really not much use, is it? Almost all languages make use of at least the posix syscall interfaces provided by the OS, and some platforms don’t even allow you to roll your own syscalls, iirc. In my eyes it’s more important that FFI be easy, automatic, and as efficient as possible. Go imposes a significant cost on FFI, for example, and many languages have typesystems that are very unfriendly to C ABI or basically require swig. One thing I really appreciate about Lua is that I can write Lua interfaces for my classes and methods quite easily, and even use Lua as a garbage-collected allocator for native types. Automating the generation of Lua interfaces can easily be done natively with metaprogramming, without involving dependencies like swig. It’s so good that instead of feeling like you’re figuring it out on the Lua side, it’s as if Lua puts the host language first, Lua doesn’t even need to be the owner of the process. It is almost ideal other than the clumsy interface between the stack-like C side and tables, and the dynamic parameter lists. For so many languages FFI is an afterthought at best.
zerealshadowban 1y ago
ah, this is not about the Red Language that Intermetrics designed in 1977-79 to satisfy the Steelman requirements of the DoD's High Order Language Working Group... (the Green Language won and became known as Ada). I thought maybe someone had put the DoD's Red language spec online. And yes, someone has: https://iment.com/maida/computer/redref/ https://iment.com/maida/computer/redref/
bsrkf 1y ago
When I look at a programming language site, especially for a "new" language, I want a quick way to navigate to a reasonably sized decent code sample, ideally documented, showing off significant language features, idiomatic syntax and usage patterns etc... Sites which do this well (just from the top of my head): https://odin-lang.org/ immediate code sample visible "See the Full Demo" "See More Examples" https://ziglang.org/ immediate code sample scroll down a bit, "More Code Samples" Here on red-lang.org... I can barely find a consecutive meaningful chunk of code... ? "Getting Started" Nope "Documentation" Nope "Official Documentation" link to github https://github.com/red/docs/blob/master/en/SUMMARY.adoc "Home" merely a chronologically sorted blog newest entry links to 50 line "script" by chance showing off multi-monitor support (doesn't seem like a super helpful sample) ?
- LkpPo 1y ago
  You can watch https://www.red-by-example.org/ https://www.red-by-example.org/ But no one has bothered to write a complete manual like Carl did for Rebol, and the language is a partial implementation in Rebol which has a hybrid Rebol/Red syntax that must ultimately be bootstrapped in Red. In short, you have the scaffolding around it and if you are not a total fan or a dev of the project it is not even worth it.
- troupo 1y ago
  They used to promise that proper docs and everything would come when the language reaches 1.0. That was 7 years ago. The language is at version 0.6.6 today, and the state of docs is the same as 7 (and 10) years ago. There are at best two people working on the language, and they both don't have the time and have a very weird approach to docs (like posting extensive google docs or pastebin explanations, but never actually having any proper documentation)
taylorallred 1y ago
Languages that encourage making DSLs are a two-edged sword. On the one hand, you get to make a language that is more clear and fine-tuned to your use-case. On the other, you have an ad-hoc language with no support that you have to maintain along with the documentation (considering that you can't expect anyone else to know the DSL ahead of time). As I've gotten older, I've determined that well-designed APIs in a well-known language are a better alternative to DSLs.
- vidarh 1y ago
  An API is just as much a DSL.
  - bunderbunder 1y ago
    Kind of, except that a non-DSL API doesn't create any new syntax. Which means that you get to keep all sorts of quality-of-life tools like syntax highlighting and correctness checking in the editor, autoformatting, possibly some amount of linting, etc. A few years ago I revisited Racket after a long hiatus, and that was maybe the biggest thing I noticed. I really don't like syntax macros as much as I did back in the day. Once I decide to use `define-syntax` I've then got to decide whether I also want to wade into dealing with also implementing a syntax colorer or an indenter as part of my #lang. And if I do decide to do that, then I've got a bunch more work, and am also probably committing to working in DrRacket (otherwise I'd rather stay in emacs) because that's the only editor that supports those features, and it just turns into a whole quagmire. And it's arguably even worse outside of Racket, where I might have to implement a whole language server and editor plugin to accomplish the same. Versus, if I can do what I need to do with a reasonably tidy API, then I can get those quality of life things without all the extra maintenance burden. None of this was a big deal 20 years ago. My expectations were different back then, because I hadn't been spoiled by things like the language server protocol and everyone (finally) agreeing that autoformatting is a Good Thing.
    - AnimalMuppet 1y ago
      Even without the new spiffs, I still don't see the point of DSLs. From where I sit, I see exactly zero problems where I think that new syntax is what I need to be able to write a solution.
deleted 1y ago
[deleted]
fuzztester 1y ago
I have tried Rebol out a little, multiple times over the years. it's a cool language. I like it. I also got to know about Red early, followed it and tried it out for a bit. but as others have said, that move to crypto, to fund the dev work and make the devs money, put me off for good. nothing wrong with making money, let them make plenty, I just didn't jive with crypto as a way of doing it. sad about it going that route
HexDecOctBin 1y ago
So, REBOL and Red are basically Fexpr-based Lisps, right? They never describe themselves this way (instead using terms like definitional scoping, etc.), but it all just seems like a non-rigorous Fexpr based Lisp (almost like a light-weight version of vau-calculus of Kernel).
- tangus 1y ago
  I don't think in Red a function can decide whether to evaluate its arguments or not. It's more like a Logo: functions have fixed arity, so you don't need to delimite the call, and lists ("blocks") are always quoted, so you need to explicitly evaluate them.
lagniappe 1y ago
red-lang.org is blocked! Phantom believes this website is malicious and unsafe to use. This site has been flagged as part of a community-maintained database of known phishing websites and scams. If you believe the site has been flagged in error, please file an issue. Ignore this warning, take me to https://www.red-lang.org/p/about.html anyway.
- tangus 1y ago
  Not very reliable, this Phantom thing.
emmelaich 1y ago
(2011,2013) Seems the last release (alpha) was in 2015.
ksymph 1y ago
Here [0] is an example of what it looks like. Took some digging to find, really should be more prominent on the site. It's very elegant! I can't fully grasp everything that's happening but the visual appearance of the syntax alone is interesting. [0] https://github.com/red/code/blob/master/Scripts/clock.red https://github.com/red/code/blob/master/Scripts/clock.red
- throwaway17_17 1y ago
  I agree that this particular coding example looks good. I find it aesthetically pleasing for some reason. But like you I don’t know the language, which leaves me with a question, does this code make understanding the function’s operation and implicit usage contract (i.e. the function’s type) clear to a dev that does know the language? I would assume it does, because I assume I be able to know these things in a comparable JS or Python example. But if that assumption is correct I really like the ‘look’ of Red.
- cess11 1y ago
  Seems someone built an ETL product from XML to databases. https://redata.dev/smartxml/ https://redata.dev/smartxml/ If it's robust it seems rather neat.
aabbcc1241 1y ago
I know asciidoc from red and erlang, it's a nice language. Not sure why it is not as popular as markdown.
- cess11 1y ago
  It's a little more complex, but I like it too. I've worked in teams that put all in-repo documentation in Asciidoc, it was really nice for adding in diagrams of complex systems and dependency trees.
- goku12 1y ago
  There aren't many parser libraries for languages other than ruby. Its Ruby implementation, Asciidoctor, is considered as the reference implementation. However, it's being standardized and the situation will hopefully improve.
kscarlet 1y ago
> Red’s ambitious goal is to build the world’s first full-stack language, a language you can use from system programming tasks, up to high-level scripting through DSL. Pretty nonsensical statement. We have that for 50 years. Common Lisp, for example.
sim7c00 1y ago
I cant find some stuff from the docs. What i am wondering is: For 'platforms' it notes for x86_64, "linux" and other operating systems. is there a compiler option for this thing to make it spit out a 'freestanding' binary for the architectures it supports?
spjt 1y ago
Maybe it's just bias based on what I'm familiar with but I don't really like the syntax, or at least I can't understand any of it intuitively. Looking at the few examples I can find, it doesn't appear to be obvious without having to look at and interpret a bunch of surrounding context for clues to what a particular token is, e.g. a function name, a variable, an argument to a function and what function it is an argument to, the type of a variable, a value being assigned to it, etc. I see a lot of lines of code that are just several strings in a row without any sort of punctuation.
debo_ 1y ago
In Red, you'll presumably always know what color your functions are.
dittonedo 1y ago
Seems lovable
greggirwin 1y ago
1) I'm part of Team Red. 2) You can like, dislike, embrace, or discount a language (or anything for that matter) for any reason that's important to you. 3) I'm not here to convince anyone of anything, just to provide some information and my own thoughts and opinions. 4) I'm not going to justify or argue the state of things in Red today. It is what it is. Lots of high level things are easy to talk (or complain) about, while some other really cool tech lives in the shadows, but is also important. 5) In Red we call embedded DSLs "dialects", just for clarity in what I write. Red is more different than you may think, just by looking at it. It is designed such that things that look familiar may work very differently under the hood. That's good for making people comfortable, but also means you can't judge a book completely by its cover. Red is a data format first. That's very Lisp-like, but Red goes further with the large number of datatypes that have a lexical form. e.g. email, url, pair, point, file, date, time, money, etc. Where Lisp* says code is data and data is code, we tend to say "Everything is data until it is evaluated." Rebol was only interpreted, but Red (not all Red however, as some things are too dynamic and require JiT, which we don't have yet) can be compiled. Red compiles to Red/System (R/S) code. R/S is a static dialect (DSL) of Red, which compiles directly to machine code. No external compiler or C code gen. So you can write DSLs in Red, and those DSLs can be higher or lower level. We call this Metal to Meta programming. Compile a small R/S program, and you will see it's fast, and fully standalone. Compile Red in Dev mode, where the runtime isn't rebuilt, and it's also fast (after the first time). Compile in encap mode and...more to explain. Compile for release and it takes time, but gives you a standalone EXE. It's slow for a number of reasons. Just the current state of things. Compilation speed has not been a priority. On APIs vs DSLs, a key distinction for me is that API don't have a natural way to enforce the order of operations. That's where a grammar adds value. And because Red is often self-consuming data, the ability to write grammars (`parse` rules) that are very BNF/PEG like, it makes data handling quite powerful. I also think it's easier than most other systems, but that's me, and I've been in the Redbol (Red+Rebol) world for a long time. Two related notes on that. 1) `parse` is, itself a dialect of Red. 2) You can parse not only at the character/string level, but at the value and datatype level, including literal values and typesets. Typesets are a way to express datatypes that are related. e.g. the `number!` typeset matches `[integer! float! percent!]` types. All that said, Red is a multi-paradigm language, including functional (though not pure functional), so you can absolutely build things in an OOP/lib/API manner if you prefer. Infix came up, and the model is simple. Infix ops have a higher precedence than func calls, but there is no other operator precedence. Strictly left to right for ops. And, yes, operators are a datatype and you can make your own from most 2-arity funcs. Func args are not enclosed in parens or brackets. This is a fundamental aspect that takes some getting used to. Once you do, at least from what I've seen through the years, it feels natural. We call this "free ranging evaluation" and it's a powerful aspect of Red. It also plays into dialect design. Red is sufficiently flexible that you could hack around this if you want, but then you're fighting the language, rather than working with it. Red is high level and garbage collected, but it is not "safe" by some standards. Mutability is the default, values are strongly typed but variables are not, you can mix Red and Red/System pretty much however you want, and R/S is basically a C-level language. We talk about these tradeoffs a lot, and how to find a balance. Nothing comes for free. One of the main dialects in Red, along with `parse`, is the `VID Visual Interface Dialect`. This is how you describe GUIs for Red's cross platform GUI system. You could also build a tree of faces manually, or write your own GUI dialect or API. Another cross-platform note. Yes, we are 32-bit only at the moment. It hurts us as much as it hurts you. But Red can cross compile from and to any system it runs on. No other software or compilers needed; just a command line switch. One of our primary goals is to "fight software complexity". That doesn't mean Red will look like C, or JS, or Python. It doesn't mean any one thing. It means a lot of things working in concert. We also hope to keep Red small and easy to set up. Today you can still just drop the EXE somewhere and go. The toolchain (interpreter+compiler) is ~1.5M and the REPLs (text mode and GUI mode, separately) are just over ~2M. We may offer more options at some point, ideas like using LLVM come up a lot. While they solve some problems, they create others. So far, the costs have been deemed unacceptable, and we don't have any showstoppers (other than time). But since Red is open source, with a permissive license... Happy Reducing!

213 points by hotpocket777 1y ago

I figured they were cooked when they started doing weird cryptocurrency-related stuff. I really hope they get to their 1.0 release someday.

7thaccount 1y ago
Same. I was regularly following it until they started talking about an ICO and began focusing too much on making a dialect for block chain stuff. The idea between having the red system language, regular scripting language, cross platform gui, and native executables was really cool though. I remember being interested back in ~2015, so my question is...what's going on as it's been a decade. I know the project is crazy ambitious of course, but how close are we to where this is at a stage where most would consider it production worthy.
- troupo 1y ago
  IIRC think their original roadmap had 1.0 around 2020. And that was going to include everything, including async written from scratch in a language where nothing was made for async. Then the roadmap slipped, and then never mentioned again. But I haven't looked at the language or discussions around it for a long while now. Edit: found some old discussion here. In 2018 they were at version 0.6.4 https://news.ycombinator.com/item?id=18864840 https://news.ycombinator.com/item?id=18864840 In 2025 they are at version 0.6.6: https://github.com/red/red/releases https://github.com/red/red/releases
  - LkpPo 1y ago
    For me, it even went off the rails before, when Nenad went to China because he was able to raise funds for the project. But he hadn't anticipated that he would be in charge and not the other way around. The situation seems to suit him perfectly. I don't think Red has any future at this point. In any case, the roadmap has always been stratospheric.
    - em-bee 1y ago
      can you elaborate what you mean by not anticipating that he would be in charge? btw, i met him in beijing while he was there.
      - LkpPo 1y ago
        That he would not have been able to do what he hoped to do to meet other demands of his creditors. Pure speculation.
therein 1y ago
Interesting, that at least explains why this happens a little bit. https://i.imgur.com/a/phd4lVr https://i.imgur.com/a/phd4lVr
- sph 1y ago
  Holy nanny state. The authors of a language have thought about using cryptocurrency, so it's flagged as a phishing and scam site? Literally 1984.
  - skywhopper 1y ago
    It gives you a way to proceed anyway, and is opt-in, and not run by any government. How is that “nanny state”? Also, given that it doesn’t torture and murder people, it’s not quite 1984 either.
  - goku12 1y ago
    It's a community maintained block list. You may be able to do something about it. So, not 1984 all the way.
  - justin66 1y ago
    That message was created by... the state?

kstrauser 1y ago

This is a successor to REBOL[0], designed by Carl Sassenrath[1] who designed the Amiga kernel. I've looked it a few times over the years. It's neat. I've never written a single line of it, though. [0]https://en.wikipedia.org/wiki/Rebol https://en.wikipedia.org/wiki/Rebol [1]https://en.wikipedia.org/wiki/Carl_Sassenrath https://en.wikipedia.org/wiki/Carl_Sassenrath

dev_l1x_be 1y ago
"In 1988, Sassenrath left Silicon Valley for the mountains of Ukiah valley, 2 hours north of San Francisco. From there he founded multimedia technology companies such as Pantaray, American Multimedia, and VideoStream. He also implemented the Logo programming language for the Amiga, managed the software OS development for CDTV, one of the first CD-ROM TV set-top boxes, and wrote the OS for Viscorp Ed, one of the first Internet TV set-top boxes." What a legend!
- kstrauser 1y ago
  Right? And I think that's what keeps bringing me back to REBOL, and thus Red. They don't appeal to me on the face of them. Like, the code examples look interesting but in a "magical" kind of way that strikes a little bit of fear into my engineering heart. But with that kind of pedigree, I can't dismiss the ideas. If Sassenrath came up with it, I bet there's a kernel of awesomeness inside.
  - Izkata 1y ago
    I suspect a lot of the magic will fall away after realizing the block data structure (the square brackets) are pretty close to a Lisp list. And just like in Lisp, they're used for both code and data. One big difference is words are evaluated by default instead of just the first word in a list, so there's nowhere near as much nesting, and whenever an expression ends the next one can begin with no delimiter (but use newlines for legibility).
- tejtm 1y ago
  pretty sure he finished out his post Rebol career with Roku

ConanRus 1y ago

32 bit only

anta40 1y ago
Which is a deal breaker for macOS users... unless they are still on Mojave.

ttoinou 1y ago

This is like the only programming language I could never learn. I just don't understand anything and I can't build any mental model of what's going on behind the hood

almostgotcaught 1y ago
it's lisp with square braces instead of parens (and then a whole bunch of other random things like a gui library in the standard library?)
- TOGoS 1y ago
  The square brackets aren't really analogous to Lisp's parentheses; REBOL / RED use parentheses for the same purpose, if you need them. The square brackets are more like square brackets in Factor or Joy; they are 'quotations' around a list of words (or other syntactic structures; basically they make a list that is not evaluated immediately).
- timbit42 1y ago
  It's actually more like Logo, which is Lisp with square brackets instead of parens and fixed arity. Sassenrath wrote Amiga Logo before starting REBOL.
TOGoS 1y ago
I wrote a paper on REBOL back in college. It is very interesting, but the syntax is definitely weird. You might think of the function call syntax as being sort of Forth-like, but with the tokens in reverse order. So like a Lisp, but without required parentheses. e.g. in the example send friend@rebol.com read http://www.cnn.com `read` knows that it takes one argument, and `send` knows that it takes two, so this ends up being grouped like (send friend@rebol.com (read http://www.cnn.com)) (which I think is valid syntax; that AST node is called a 'paren'). Weirdly, the language also has some infix operators, which seem a bit out-of-place to me. I have no idea how the 'parser'[1] works. [1] 'parsing' happens so late that it feels funny to call it that. The thing that knows how to treat an array as a representation of an evaluatable expression and evaluate it.

croemer 1y ago

The website looks like 2013 and much of the content is as well. There's a GitHub repo that I couldn't find from the website: https://github.com/red/red https://github.com/red/red

worldsayshi 1y ago
The repo seems to be alive and kicking.
pabs3 1y ago
The website links to GitHub with the usual logo, in the right hand column. The website has posts from 2025: https://www.red-lang.org/2025/04/multiple-monitors-support.html https://www.red-lang.org/2025/04/multiple-monitors-support.h... Unless you mean the theme, thats probably just a standard Google Blogger/Blogspot theme, which has been around for 25 years. https://en.wikipedia.org/wiki/Blogger_(service) https://en.wikipedia.org/wiki/Blogger_(service)
- croemer 1y ago
  The mobile website is different than the desktop version, that's not very common anymore. There's no GitHub logo in the mobile version.

niek_pas 1y ago

I haven’t looked at this in detail, but it seems they confuse “human-friendly syntax” with “absence of (<[{“.

38 1y ago

red was terrible in 2018, and its terrible now - just tried to compile hello world and it takes 36 seconds https://github.com/red/red/issues/5615 https://github.com/red/red/issues/5615

burnt-resistor 1y ago
Go compiles massive codebases in that time. V can recompile itself probably 2-3x in that time. I don't take any new language seriously unless it's memory safe, free of UB, able to interoperate with what already exists including optional shared libraries (because static linking the world every time in everything is memory and disk wasteful), and assists formal proofs of correctness. Otherwise, what already exists seems preferable for serious use and hobbies can remain fun distractions.
- 38 1y ago
  troll spotted
- binary132 1y ago
  If a language can’t use shared objects at all, it’s really not much use, is it? Almost all languages make use of at least the posix syscall interfaces provided by the OS, and some platforms don’t even allow you to roll your own syscalls, iirc. In my eyes it’s more important that FFI be easy, automatic, and as efficient as possible. Go imposes a significant cost on FFI, for example, and many languages have typesystems that are very unfriendly to C ABI or basically require swig. One thing I really appreciate about Lua is that I can write Lua interfaces for my classes and methods quite easily, and even use Lua as a garbage-collected allocator for native types. Automating the generation of Lua interfaces can easily be done natively with metaprogramming, without involving dependencies like swig. It’s so good that instead of feeling like you’re figuring it out on the Lua side, it’s as if Lua puts the host language first, Lua doesn’t even need to be the owner of the process. It is almost ideal other than the clumsy interface between the stack-like C side and tables, and the dynamic parameter lists. For so many languages FFI is an afterthought at best.

zerealshadowban 1y ago

ah, this is not about the Red Language that Intermetrics designed in 1977-79 to satisfy the Steelman requirements of the DoD's High Order Language Working Group... (the Green Language won and became known as Ada). I thought maybe someone had put the DoD's Red language spec online. And yes, someone has: https://iment.com/maida/computer/redref/ https://iment.com/maida/computer/redref/

bsrkf 1y ago

When I look at a programming language site, especially for a "new" language, I want a quick way to navigate to a reasonably sized decent code sample, ideally documented, showing off significant language features, idiomatic syntax and usage patterns etc... Sites which do this well (just from the top of my head): https://odin-lang.org/ immediate code sample visible "See the Full Demo" "See More Examples" https://ziglang.org/ immediate code sample scroll down a bit, "More Code Samples" Here on red-lang.org... I can barely find a consecutive meaningful chunk of code... ? "Getting Started" Nope "Documentation" Nope "Official Documentation" link to github https://github.com/red/docs/blob/master/en/SUMMARY.adoc "Home" merely a chronologically sorted blog newest entry links to 50 line "script" by chance showing off multi-monitor support (doesn't seem like a super helpful sample) ?

LkpPo 1y ago
You can watch https://www.red-by-example.org/ https://www.red-by-example.org/ But no one has bothered to write a complete manual like Carl did for Rebol, and the language is a partial implementation in Rebol which has a hybrid Rebol/Red syntax that must ultimately be bootstrapped in Red. In short, you have the scaffolding around it and if you are not a total fan or a dev of the project it is not even worth it.
troupo 1y ago
They used to promise that proper docs and everything would come when the language reaches 1.0. That was 7 years ago. The language is at version 0.6.6 today, and the state of docs is the same as 7 (and 10) years ago. There are at best two people working on the language, and they both don't have the time and have a very weird approach to docs (like posting extensive google docs or pastebin explanations, but never actually having any proper documentation)

taylorallred 1y ago

Languages that encourage making DSLs are a two-edged sword. On the one hand, you get to make a language that is more clear and fine-tuned to your use-case. On the other, you have an ad-hoc language with no support that you have to maintain along with the documentation (considering that you can't expect anyone else to know the DSL ahead of time). As I've gotten older, I've determined that well-designed APIs in a well-known language are a better alternative to DSLs.

vidarh 1y ago
An API is just as much a DSL.
- bunderbunder 1y ago
  Kind of, except that a non-DSL API doesn't create any new syntax. Which means that you get to keep all sorts of quality-of-life tools like syntax highlighting and correctness checking in the editor, autoformatting, possibly some amount of linting, etc. A few years ago I revisited Racket after a long hiatus, and that was maybe the biggest thing I noticed. I really don't like syntax macros as much as I did back in the day. Once I decide to use `define-syntax` I've then got to decide whether I also want to wade into dealing with also implementing a syntax colorer or an indenter as part of my #lang. And if I do decide to do that, then I've got a bunch more work, and am also probably committing to working in DrRacket (otherwise I'd rather stay in emacs) because that's the only editor that supports those features, and it just turns into a whole quagmire. And it's arguably even worse outside of Racket, where I might have to implement a whole language server and editor plugin to accomplish the same. Versus, if I can do what I need to do with a reasonably tidy API, then I can get those quality of life things without all the extra maintenance burden. None of this was a big deal 20 years ago. My expectations were different back then, because I hadn't been spoiled by things like the language server protocol and everyone (finally) agreeing that autoformatting is a Good Thing.
  - AnimalMuppet 1y ago
    Even without the new spiffs, I still don't see the point of DSLs. From where I sit, I see exactly zero problems where I think that new syntax is what I need to be able to write a solution.

deleted 1y ago

[deleted]

fuzztester 1y ago

I have tried Rebol out a little, multiple times over the years. it's a cool language. I like it. I also got to know about Red early, followed it and tried it out for a bit. but as others have said, that move to crypto, to fund the dev work and make the devs money, put me off for good. nothing wrong with making money, let them make plenty, I just didn't jive with crypto as a way of doing it. sad about it going that route

HexDecOctBin 1y ago

So, REBOL and Red are basically Fexpr-based Lisps, right? They never describe themselves this way (instead using terms like definitional scoping, etc.), but it all just seems like a non-rigorous Fexpr based Lisp (almost like a light-weight version of vau-calculus of Kernel).

tangus 1y ago
I don't think in Red a function can decide whether to evaluate its arguments or not. It's more like a Logo: functions have fixed arity, so you don't need to delimite the call, and lists ("blocks") are always quoted, so you need to explicitly evaluate them.

lagniappe 1y ago

red-lang.org is blocked! Phantom believes this website is malicious and unsafe to use. This site has been flagged as part of a community-maintained database of known phishing websites and scams. If you believe the site has been flagged in error, please file an issue. Ignore this warning, take me to https://www.red-lang.org/p/about.html anyway.

tangus 1y ago
Not very reliable, this Phantom thing.

emmelaich 1y ago

(2011,2013) Seems the last release (alpha) was in 2015.

ksymph 1y ago

Here [0] is an example of what it looks like. Took some digging to find, really should be more prominent on the site. It's very elegant! I can't fully grasp everything that's happening but the visual appearance of the syntax alone is interesting. [0] https://github.com/red/code/blob/master/Scripts/clock.red https://github.com/red/code/blob/master/Scripts/clock.red

throwaway17_17 1y ago
I agree that this particular coding example looks good. I find it aesthetically pleasing for some reason. But like you I don’t know the language, which leaves me with a question, does this code make understanding the function’s operation and implicit usage contract (i.e. the function’s type) clear to a dev that does know the language? I would assume it does, because I assume I be able to know these things in a comparable JS or Python example. But if that assumption is correct I really like the ‘look’ of Red.
cess11 1y ago
Seems someone built an ETL product from XML to databases. https://redata.dev/smartxml/ https://redata.dev/smartxml/ If it's robust it seems rather neat.

aabbcc1241 1y ago

I know asciidoc from red and erlang, it's a nice language. Not sure why it is not as popular as markdown.

cess11 1y ago
It's a little more complex, but I like it too. I've worked in teams that put all in-repo documentation in Asciidoc, it was really nice for adding in diagrams of complex systems and dependency trees.
goku12 1y ago
There aren't many parser libraries for languages other than ruby. Its Ruby implementation, Asciidoctor, is considered as the reference implementation. However, it's being standardized and the situation will hopefully improve.

kscarlet 1y ago

> Red’s ambitious goal is to build the world’s first full-stack language, a language you can use from system programming tasks, up to high-level scripting through DSL. Pretty nonsensical statement. We have that for 50 years. Common Lisp, for example.

sim7c00 1y ago

I cant find some stuff from the docs. What i am wondering is: For 'platforms' it notes for x86_64, "linux" and other operating systems. is there a compiler option for this thing to make it spit out a 'freestanding' binary for the architectures it supports?

spjt 1y ago

Maybe it's just bias based on what I'm familiar with but I don't really like the syntax, or at least I can't understand any of it intuitively. Looking at the few examples I can find, it doesn't appear to be obvious without having to look at and interpret a bunch of surrounding context for clues to what a particular token is, e.g. a function name, a variable, an argument to a function and what function it is an argument to, the type of a variable, a value being assigned to it, etc. I see a lot of lines of code that are just several strings in a row without any sort of punctuation.

debo_ 1y ago

In Red, you'll presumably always know what color your functions are.

dittonedo 1y ago

Seems lovable

greggirwin 1y ago

1) I'm part of Team Red. 2) You can like, dislike, embrace, or discount a language (or anything for that matter) for any reason that's important to you. 3) I'm not here to convince anyone of anything, just to provide some information and my own thoughts and opinions. 4) I'm not going to justify or argue the state of things in Red today. It is what it is. Lots of high level things are easy to talk (or complain) about, while some other really cool tech lives in the shadows, but is also important. 5) In Red we call embedded DSLs "dialects", just for clarity in what I write. Red is more different than you may think, just by looking at it. It is designed such that things that look familiar may work very differently under the hood. That's good for making people comfortable, but also means you can't judge a book completely by its cover. Red is a data format first. That's very Lisp-like, but Red goes further with the large number of datatypes that have a lexical form. e.g. email, url, pair, point, file, date, time, money, etc. Where Lisp* says code is data and data is code, we tend to say "Everything is data until it is evaluated." Rebol was only interpreted, but Red (not all Red however, as some things are too dynamic and require JiT, which we don't have yet) can be compiled. Red compiles to Red/System (R/S) code. R/S is a static dialect (DSL) of Red, which compiles directly to machine code. No external compiler or C code gen. So you can write DSLs in Red, and those DSLs can be higher or lower level. We call this Metal to Meta programming. Compile a small R/S program, and you will see it's fast, and fully standalone. Compile Red in Dev mode, where the runtime isn't rebuilt, and it's also fast (after the first time). Compile in encap mode and...more to explain. Compile for release and it takes time, but gives you a standalone EXE. It's slow for a number of reasons. Just the current state of things. Compilation speed has not been a priority. On APIs vs DSLs, a key distinction for me is that API don't have a natural way to enforce the order of operations. That's where a grammar adds value. And because Red is often self-consuming data, the ability to write grammars (`parse` rules) that are very BNF/PEG like, it makes data handling quite powerful. I also think it's easier than most other systems, but that's me, and I've been in the Redbol (Red+Rebol) world for a long time. Two related notes on that. 1) `parse` is, itself a dialect of Red. 2) You can parse not only at the character/string level, but at the value and datatype level, including literal values and typesets. Typesets are a way to express datatypes that are related. e.g. the `number!` typeset matches `[integer! float! percent!]` types. All that said, Red is a multi-paradigm language, including functional (though not pure functional), so you can absolutely build things in an OOP/lib/API manner if you prefer. Infix came up, and the model is simple. Infix ops have a higher precedence than func calls, but there is no other operator precedence. Strictly left to right for ops. And, yes, operators are a datatype and you can make your own from most 2-arity funcs. Func args are not enclosed in parens or brackets. This is a fundamental aspect that takes some getting used to. Once you do, at least from what I've seen through the years, it feels natural. We call this "free ranging evaluation" and it's a powerful aspect of Red. It also plays into dialect design. Red is sufficiently flexible that you could hack around this if you want, but then you're fighting the language, rather than working with it. Red is high level and garbage collected, but it is not "safe" by some standards. Mutability is the default, values are strongly typed but variables are not, you can mix Red and Red/System pretty much however you want, and R/S is basically a C-level language. We talk about these tradeoffs a lot, and how to find a balance. Nothing comes for free. One of the main dialects in Red, along with `parse`, is the `VID Visual Interface Dialect`. This is how you describe GUIs for Red's cross platform GUI system. You could also build a tree of faces manually, or write your own GUI dialect or API. Another cross-platform note. Yes, we are 32-bit only at the moment. It hurts us as much as it hurts you. But Red can cross compile from and to any system it runs on. No other software or compilers needed; just a command line switch. One of our primary goals is to "fight software complexity". That doesn't mean Red will look like C, or JS, or Python. It doesn't mean any one thing. It means a lot of things working in concert. We also hope to keep Red small and easy to set up. Today you can still just drop the EXE somewhere and go. The toolchain (interpreter+compiler) is ~1.5M and the REPLs (text mode and GUI mode, separately) are just over ~2M. We may offer more options at some point, ideas like using LLVM come up a lot. While they solve some problems, they create others. So far, the costs have been deemed unacceptable, and we don't have any showstoppers (other than time). But since Red is open source, with a permissive license... Happy Reducing!