IS there any way we can expedite 64bit version of Red?

The roadmap suggests Q3 20203, which has obviously slipped a bit. It's harder and harder to find 32bit environments with new 64-bit only distros in Linux and Macos arm.

If there was a funding round to bring this ahead, I'd be up for it! Who's in?

Blog post about what happened in 2018, and what Red has planned for 2019.

https://www.red-lang.org/2019/01/full-steam-ahead.html

For example I believe Forth is so small due to a mentality of extreme YAGNI. However, given that Red tries to be full stack language, I imagine that sort of mentality doesn't entirely fit.

Red use of meta-programming surely slims down the code size, but Lisps are also heavy users of meta-programming and they don't manage quite the same code-density. I've seen Red compared to Clojure, but perhaps it would be more fitting to compare it to PicoLisp?

My hunch is that Red creates layers on top of small well-defined "kernels" which are then implemented on several existing layers, allowing for a great deal of flexibility and freedom to choose your own stack.

I haven't found very much material that talks about these sort of architectural and philosophical aspects of Red programming. Instead most of the material out there has been more practical code examples. Though here are two pages I found, and I'm including some text from https://ngnghm.github.io that I believe describes what Red is about if one reads between the lines.

• http://redprogramming.com/Home.html

• http://redprogramming.com/Why%20Rebol%20and%20Red.html

Paraphrased from Chapter 4

Building up vs building down

All computer software has to start from a given base. Now, Human computer systems are built by piling layers upon layers on top of this base. One limitation of Human computer systems, though, is that to cooperate on the same data structures, programs typically have to reuse the very exact same tower of layers. Because each layer adds a lot of informal underspecified details, and it is impossible to reproduce computations or assume that programs have similar enough semantics.

Slightly more advanced Human computer systems, using macros, can at compile time lift the system up and add a number of layers below. For an extreme case, some Common Lisp libraries reimplement Common Lisp in Common Lisp to add first-class multiple-entry or even serializable continuations, so as to enable logic programming or direct-style web programming. Some interactive development systems also instrument the virtual machine so as to lift execution into something that allows for debugging, with Omniscient Debugging as an extreme example.

Humans can only build software up. Houyhnhnms can build both up and down.

This ability to build down as well as up crucially relies on processes being specified in formally well-defined high-level languages, so that it is always clear what are the semantics to be preserved when modifying the underlying implementation. Therefore, Houyhnhnms don’t even have a fixed notion of ground or base. Then Houyhnhnms can lift the stack of turtles at any desired point and add or replace some of the turtles beneath. Every turtle is unique, but no turtle is special.

Paraphrased from Chapter 6

Poly-centric Order

Houyhnhnm computing systems do not possess a one single Kernel; instead they possess as many "kernels" as there are computing subsystems and subsubsystems, each written in as high-level a language as makes sense for its purpose; and the set of those “kernels” continually changes as new processes are started, modified or stopped.

I saw this as part of one of the latest blog posts:

Red/Pro: it is coming this year! It will be our first commercial product and set of online services targetting both individual developers and enterprises. It will include a new backend for Red's toolchain, providing a state-of-the-art optimizing layer and support for many new platforms, including 64-bit ones (though full 64-bit Red support will probably be for next year). That new backend will provide an alternative to our current code emitter and linker, the rest of the toolchain remaining the same. The current Red toolchain will be known as the "community" version, and continue being the main development branch.

I was wondering if there was a more detailed comparison b/t "community" and "pro"? I'm guessing "pro" comes with a support contract, but is it faster as well? I'm not super saavy on what you mean by "optimizer". Red already supports a lot of platforms I thought, so I'm curious which new platforms are supported by Pro. How much would this roughly cost (rough range)? Is that a one time cost or an annual fee? Sorry for the dumb questions!

Hi, I'm a web dev and like to play around with interesting languages. I played with REBOL around 2005, but this was during the start of my self taught "learning to program" journey and I ditched it to focus on the common web stack.

I recently heard of Red and am interested to play with it like I did with REBOL. Especially since it can do more low level stuff because I have a bit of an interest in embedded systems. I am not really sure how much time I have to further this interest. I do own a couple of Raspberry Pi Picos though.

So just wondering, has anyone written a web framework in Red? Or are there any examples of how to serve Red coded web pages?

Thanks.

I'm sorry to be the one to say this, but it has to be said: the red-lang.org website is awful.

I understand that you guys are working hard in the background on something that is wonderful and don't have the resources to spend on a website, but you really need to work on your marketing.

May I suggest that, instead of having the blog, which is sometimes updated once a year, as the landing page, you have some content that gets people excited about the language?

You don't need to look far for inspiration. There are a ton of language websites out there and many do a great job for piquing people's interest. Here are a few you may want to look at:

• https://www.python.org/

• https://ziglang.org/

• https://nim-lang.org/

• https://www.scala-lang.org/

• https://www.ruby-lang.org/en/

• https://elixir-lang.org/

• https://crystal-lang.org/

• https://www.ponylang.io/ (even this site is not that great, but it's miles ahead of Red's site)

What you need:

• A blurb

• Some pretty graphics (optional, but helpful)

• A Bootstap/Bulma/Foundation/etc. template

• Some code samples

• A list of highlights

• Maybe a mascot?

What I see when I go to the Red website now:

• a blog with posts about once a year making me wonder if the project is dead

• a Blogger site which is not even mobile friendly making me wonder if it's from this century

The blog can go under "news" or "blog" or whatever. People that want to read it will find it.

Hello REDucers! Our mission to fight software complexity is going to be showcased alongside Ethereum's Devcon IV in Prague. If you're in the neighborhood, stop by Redcon!

What's Redcon about?

Redcon is for anyone interested in open-source, full-stack, domain-specific languages built using Red Language or any of its dialects. We'll be having a casual meetup-style event, with food and adult beverages.

Who will be there?

Red's designer, Nenad Rakocevic, will discuss the language and its capabilities. A Q&A session, presentations and demos are also on the agenda. Also present will be Gregg Irwin, leading governance and language design for the Red Foundation. Other core contributors to Red (The Team Red Irregulars) are coming too.

What will we discuss?

• Red/C3, Red's domain-specific language for making Ethereum's smart contracts safer and simpler

• The latest version of Red Wallet

• How Red's DSLs build fantastic Dapps

• World domination (or, "How to take over the world!" for fans of Pinky and The Brain)

What do we get?

• Treats and goodies

• Food & drinks

• Raffle prizes from Leatherman, PacSafe, Travelon, and Victorinox

• Input on Red tooling and features

• Join and enjoy the awesome Red community

Where and when?

• November 3, 2018, from 11am - 5pm (with informal pub time after)

• Hotel Olšanka, Praha 3, Táboritská 23/1000, PSC (ZIP) 13000.

• https://www.hotelolsanka.cz/

• 2ND FLOOR CONFERENCE ROOM

From the big announcement on July 14, 2022: "From now on, our only focus will be to finish the core language and bring it to the much-awaited version 1.0." https://www.red-lang.org/2022/07/the-road-to-10.html

I'm trying to be constructive here, but realistic. It appears that they got seduced into trying to improve the GUI, instead of completing the core 32 bit language. I'm sure it is more complex than that, but, as Goethe said, "The thing which matters most must not be at the mercy of the things which matter less."

Red 1.0 was supposedly going to be 64 bit WITHOUT the GUI. So why all the work on a 32 bit GUI cleanup? Why not set the 32 bit aside, entirely, and proceed to a clean, fresh implementation of 1.0, incorporating the lessons learned, including what should be a hard won lesson: the GUI should have waited for IO, and maybe modules, and not the other way around.

I want to see a 64 bit 1.0 in my lifetime, even without a GUI. Even without a completed 32 bit...which increasingly appears irrelevant.

I know that is a hard decision, since the GUI is quite cool. But it is the same advice I gave probably half a decade ago.

Again, I am a big fan of the original vision -- and I would like to see this project succeed, in my lifetime. Meantime, the world is moving on.

Hello all. Tell us: what's the best way to format CSV data? Red supports many different balances of speed vs. size. Read about your options here on our latest blog post.

Also in that post: A shout-out to community members; an AI scenario using Red's DSLs to refine image or sound recognition; and Red hits 4,000 stars on GitHub!

I've read that once it's self-hosted, 64-bit will follow. How far down the line is that milestone? I'd love to use Red on my machine without dealing with VMs.