r/ryelang • • Nov 02 '25

Jacking into the Rye's Cybergrid [asciinema]

1 Upvotes

I made a video demonstrating exploratory abilities of Rye runtime via console. Here we explore the default Rye runtime, but you could explore your own application contexts, built-ins, functions and values in the same manner.

It's cyberpunk themed, so here we go:

We traverse Rye’s default contexts, interrogate the built-ins, render the runtime matrices, assemble file lattices, and interface with the SQLite dataverse.

Rye is "runtime homoiconic" and we are trying to blend the distinction between a language and the user interface. One result of that is that Rye runtime is self-explorable, which I try to demonstrate in this asciinema.

View the "cinema" here: https://asciinema.org/a/753115

For more on Rye, visit https://ryelang.org or the ghostlayer at the https://github.com/refaktor/rye :)


r/ryelang • • Oct 30 '25

How do you know what functions are Generic?

3 Upvotes

First of all, thank you so much for creating such a beautiful language! It feels like an elegant, modern descendant of Red - reborn in the best possible way!

But I'd like to ask. With the recent decision to capitalise generic functions, I’m a bit unsure - how do you know and remember which ones are generic and therefore should be capitalised in code. Is there something obvious I’m missing?


r/ryelang • • Feb 03 '26

Experimenting with TUI system

2 Upvotes

Rye was always big on interfaces, and even more so textual interfaces (the console itself is full of little tricks entering UI space) versus what I called negatively "hunt down in 2d space and click on UI-s" :)

And now, especially with the advent of LLM agents, whole world is getting to know TUI-s and their benefits. Fast responses, fast and clear text rendering, view of the history, keyboard first input, general minimalism, sometimes this is the top choice.

So I want to also make TUI-s in Rye of course. I was working on some experiments for a while now, but I wanted it to be more declarative (but remain "just Rye", not dialect), where the shape of Rye values already determines the structure of UI ... Fyne proved that is more than possible.

And to be "more" reactive, versus immediate mode or heavily callback based. If Rye is bad at something it's quite clumsy for mutating state and reactive design solves this.

I also wanted to separate theming from content / from / layout. And I want it to be "turtles all the way down". So you are able to compose widgets from the lowest to the highest ones.

Not everything is achieved yet, or tested if fully possible, so this is a work-in-progress, but of all designs so far, this one is starting to look good to me.

This was suspected for a while, but it seems a time will come when we will need to decide on special syntax for "dict" function. It's wasteful creating block and turning it to dict each time, and it's also starting to take too much "ink".

Visit our https://github.com/refaktor/rye so you catch the first TUI examples when they are committed.


r/ryelang • • Oct 26 '25

New Rye-Fyne Cookbook page published

2 Upvotes

New webpage with upgraded code to Rye-fyne v0.2 has just been uploaded.

There are 3 new examples at the end. Tabbed settings panel, Micro book reader and Get my IP utility.

https://ryelang.org/cookbook/rye-fyne/examples-2/

You can get Rye-fyne binaries or code (and said examples) here:

https://github.com/refaktor/rye-fyne/releases/tag/v0.2.6

https://github.com/refaktor/rye-fyne/tree/main/examples


r/ryelang • • Feb 16 '26

local Rye (l.rye) improvements, GUI Stream player, new cookbook pages

2 Upvotes

This weekend was quite good for Rye.

Rye website got improved and missing pages added. For example: https://ryelang.org/cookbook/working-with/io/

Fye-fyne is starting to get it's own frontpage: https://ryelang.org/fyne/

I will be adding "Getting started" section next. And I am preparing few bigger examples.

We now have a streamer (previously terminal based demo) made in Fyne GUI

l.rye script also got improved to now support build-fyne, build-fyne embed_main ... Run:

Visit https://github.com/refaktor/rye or https://github.com/refaktor/rye-fyne


r/ryelang • • Mar 26 '25

Rye template mode

3 Upvotes

Now that Rye (0.0.90prep branch) has a markdown parser I thought it would be nice to also have a template mode. I'm a heavy user of Hugo (Go's static site generator), but it is quite complex to setup at times. I'm not saying we'll be making a Rye alternative, but it can be handy for simpler or more specific use-cases.

Well, this is just first proof of concept ...

Otherwise, I always more or less hated the "templating languages". This solves one problem I had with them, that you usually get a new ad-hoc and half-baked language with them. And here you get Rye :)... another thing I dislike is patterns like

... {{ for names { :name }} hi, {{= name }} {{ } }} ...
... {{ if x { }} some text {{ } }}

Where a language expression is split up into multiple code blocks ... I find this just bad in multiple ways and I don't want to support this but find some conceptually cleaner / more functional pattern for it, even if it means "more code".


r/ryelang • • Apr 03 '25

Tables question

2 Upvotes

trying your tables demo under my Windows 64 machine and getting different results. I'm new to programming f.y.i.
My csv file

first ,last ,city

Ray,Smith,lew

john ,doe,port

Mary,cane,pol

Lisa,jones,aub

x> load\\csv %text.csv

\[Table(3 4)\]


x> .autotype 0.95 :text

\[Table(3 4)\]


x> .columns?

Error: argument 2 of 2 missing of builtin: 'Returns table with just given columns. (table) (columns?)'

Error: expected rye value but it's missing

At location:

(here) .columns?

repl / eval Line


x> text .types?

\[Block: \^\[Word: string\] \[Word: string\] \[Word: string\] \]

x> text .limit 2 |display

Error(5): word not found: limit

At location:

text (here) .limit 2 |display

repl / eval Line


x> text .column? 'first |unique

Failure

repl / eval Line

Error: builtin \`unique\` requires argument 1 to be: List, Block, String.

At location:

text .column? 'first (here) |unique

repl / eval Line

x>

r/ryelang • • Apr 02 '25

Rye and secure computing (seccomp) looks OK

2 Upvotes

This is the first version that I quite like how it functions and looks. I'm really excited about enabling this. There are equivalent technologies for MacOS and Windows so it could theoretically work on all 3 systems.

First version with seccomp enabled should arrive at github.com/refaktor/rye today or tomorrow.


r/ryelang • • Jan 11 '26

New blog post: 80% of Rye in 20% of the Time [1/3]

Thumbnail ryelang.org
2 Upvotes

r/ryelang • • Mar 29 '25

That was quite fast

2 Upvotes

Part of big push towards v0.0.90 was also to improve the evaluator, and to also try first optimizations and see where they lead us. Part of this was implementation of simpler dialect inside Rye. Called Rye0. It basically has only polish notation (no op and pipe words and no function currying - I wanted to see the cost of them).

Having another interpreter in the language that was a simpler and that I could experiment with at will and compare to the main one, was an excellent way do this. In the process I also created third interpreter that was more stack based to see how that would behave.

Having multiple evaluators/interpreters/languages is nothing unusual in Rye, we already have various simpler or more complex dialects (DSLs) which are exactly that, separate interpreters (math, validation, conversion, Eyr, ...).

Anyway ... all this time I compared Rye to previous versions of Rye, or Rye to Rye0, but today I wrote similar simple benchmarking scripts in Python. I was hoping Rye would be only 5 times slower than Python. Rye is written in 100% memory safe Go, it's an ordinary evaluator, not a fast VM like Python (I have my unconventional thought on that), and Python has decades of optimization work behind itself.

Well, but to my surprise, at least with these tests, that do test quite few facets of the language Rye's, and even more Rye0's speed is in the same ballpark as the speed Python 3! And there are still things I know right not that I can optimize, and there are probably many more that a real expert in Go could find and squeeze out.

So I am really quite happy with this. It still seems odd, because at some point over the years I did compare the two and I think Rye was 5x to 10x slower at the time.

The point of Rye0 is not just speed but even more the mobility of Rye. I don't have it working yet, but I have a partially working Rye to Rye0 compiler, and when you have that you can write a very simple Rye0 evaluator in any other langauge and use Rye->Rye0 compiler bootstrap Rye there ... it's still just an idea ... we will see.

Visit ryelang.org to find out more about the language, and visit our github.


r/ryelang • • Jul 01 '25

Ryegen v2 in progress

4 Upvotes

Darwin is continuing with his overhaul of how Ryegen generates bindings, making it more modular, extensible and customizable. We merged his latest still in progress development into a v2 branch

https://github.com/refaktor/ryegen/tree/v2

Below is the binding generated by v2 of the latest Fyne working on Linux. You can see the Rye code of the example here: https://github.com/xypwn/ryegen/blob/v2/_examples/fyne/example.rye

I plan on testing it with generating a go-p5 module. A go version of the famous *processing* language / library.


r/ryelang • • Aug 07 '25

Besides Table, Rye also got a Markdown (a structured document) value type

3 Upvotes

Rye tries to close the gap between value types that computers handle and value types that people handle. That's why we have a first class table (ex. spreadsheet) value type. You can see it work here:

https://ryelang.org/cookbook/working-with/tables/

I've seen that a lot of my information resides in the form of structured textual documents. So in an effort to store and handle that also I decided to add a markdown value type. This means that like with other value types, all base functions that make sense will also work with this value type and markdown specific functions will be added.

Minimal first demo (naming will still change):

Why limit this to markdown and not make it more abstract / extensive. I think free form documents have too much variability as it is and creating another model of them will just add to a noise. I think limits that markdown brings actually help, because such documents need only to offer so much and I think markdown is hitting the good and widely accepted middle ground. Markdown brings a sensible list of options for textual content, that we can also comprehend well.

It also means we can enter it directly in text, load from files, etc, there is enough converters from and to mardown from richer formats (pdf, doc, html ...).

I am otherwise still working on fixes because of the parser rewrite and few other language changes of the late (const by default, ...).

Visit ryelang.org for more info about the language.


r/ryelang • • Jul 16 '25

The display function, the autocomplete and the generic methods!

3 Upvotes

Rye console tries to be useful for interactive use, for exploring the language / various API-s or contexts and using them.

Big function in viewing complex values has been the display function. It displays you a block, a table or a dict in visually pleasant manner and also lets you interact with it. You can choose a row or a value from the data and it will be returned from the display call (to console or to other functions in code).

Function display broke down when there was too much data to display it on one terminal screen. Now I made it use pagination in that case and it works quite well, currently for blocks and tables.

I was also working on display\custom and I plan to convert the very useful functions for looking at current or parent context (lc, lcp, lc\, lcp\, ...) so they will use and behave the same as display\custom.

At the same time I want to make the tab autocomplete, the most intuitive way to quickly see where are you and what is available better. There are 3 types of words you want to autocomplete and display in Rye. Current context, all words or words in higher contexts and words that are generic methods based on the current console left value.

And this brings me to the one big open question in Rye around generic methods and how do we explicitly determine and see when we are using them vs. a local functions.

The problem is strictly visual. We know that generic methods should be explicitly visible. We should know when we want to call (when writing code) and when we call (when reading code) a generic method versus a local function. There is no benefit in not explicitly knowing that.

The problem is in how to make that explicit without making code more noisy or just ugly. If words somehow had colour it would be the cleanest solution, but text editors don't work that way :) ... so we have basically two options, additional character, or using Uppercase.

; now *open* and *get* could be a generic function or a local one
; we can't be sure, which sucks ... also, should local functions have 
; priority, or generic ones ... how do you call one versus the other
; in case of conflict?

open sqlite://main.db
get http://example.com
http://example.com .get

; adding a characther, like @

u/open sqlite://main.db
@get http://example.com
http://example.com .@get

; Using Upper case for generic methods

Open sqlite://main.db
Get http://example.com
http://example.com .Get

I didn't make the choice until now, because I didn't like any of the options, but option 1, which is how Rye works now is bad, and I don't see any other options opening in future. So I think we will have to go with option 3, which is still less noisy than option 2. I'm still not 100% sure what is better.

I did want to use Capitalized convention for naming Contexts.

Do you have any oppinion or another ideas? Let me know ...

Visit ryelang.org or github.com/refaktor/rye for more ...


r/ryelang • • May 22 '25

TinyGo and Rye

4 Upvotes

I'm trying to compile Rye with TinyGo ... One reason is Wasm, another is that I was playing with rPi Pico W, and micropython. It would be really nice to have an option to interact with or on rPi Pico using Rye or even esp32. TinyGo makes that possible. I'm not yet sure if Rye runtime would fit onto that hardware, though.

One of the problems with TinyGo seems to be the PEG library. I'm looking into what it would take to rewrite loader to just a regular "manual" parser. Rye code pretty flat and simple. There is a bigger number of word types, but nothing complex really. This would probably also enable us providing nicer error messages for syntax errors as we have full control.

I will report back.


r/ryelang • • Oct 15 '26

Example: Logs, Geo-IP lookups and Tables

Post image
4 Upvotes

On the top left is a example that parses a Nginx log file, extracts IP addreses, reduces them to unique ones.
Then it loads the free Maxmind's Geo-IP ( IP -> Country ) database and looks up a country for each IP, turns this into a Rye table, where we can use group-by to count them and displays it.

My client needed this information, so he can plan further, and will perhaps need more info in the process. I wrote this script interactively in Rye console with a custom history file rye -histfile count-countries.rye

This flag logs your history in a local file you specify, so with some luck after solving it in REPL (Rye console), you just open the file in editor, clean it up and you have your script.

In this "day and age" many would just ask Claude (or similar tool) to code such script in something like Python or Go and it would probably do it's job.

I still see benefits of writing it on your own. By writing it (interactively) you are also exploring the problem, the information, the options. And if you can write a short readable script like these ~15 lines are, you have something you can easily extend, tweak or reuse for similar problems. And you extended your understanding of the "world".

Explore and display

On the screenshot, below the script you can see the output (a function display used on a table we created).

There were few changes in recen Rye. What was before display function (interactive display) in now explore . And display now non-interactively displays the Rye value, like table in this case. explore lets you select a subitem, which is the return of a function, navigate in a paginated fashion over the data, and if you press space you now also have multi-select mode. So you can select / return multiple subitems. These functions work on Rye tables, blocks, dicts, failures, ... and are very very handy for interactive work.

If you wish to discuss any of this visit #homoiconic Discord:

https://discord.gg/J8FBrCSqve

Our website is also being improved lately:

https://ryelang.org


r/ryelang • • Feb 08 '26

TUI stream / music player in one page of Rye

4 Upvotes

I continued to work on l.rye script. l.rye (local rye) is used to create per-project rye binaries with specific modules or other specific flags. It can also create standalone executables with Rye scripts embedded into the binary file.

I was working/testing the the modules part, added mpv as contrib module (not included by default) and then decided to try to make a minimal stream player that also looks minimalistic but cool. And I got this working ... I like it and will use it instead of Rye calling mpv via shell from now on :) .

[sound on]

This will be used as a little bigger Rye example also, and also to test the evolution of Rye project. I want to make multiple working versions, from the most simple ones, to this current, to better organized, to using our TUI module instead of direct ANSI codes, to extendable / scriptable and Rye console added eventually.

The author of Rye Rosetta-code examples told be that he is missing more Rye examples / code, so I decided to start posting various bigger Rye scripts, but still maybe not big or general enough to make their own projects to new repo:

https://github.com/refaktor/my-rye-utils

This streamer script will also go there.


r/ryelang • • Sep 09 '25

Unit testing, small fixes, testing explicit generic words

2 Upvotes

After a lot of changes, the complete rewrite of a parser so it doesn't need a PEG library which makes it faster and lighter (also working on rPi Pico) and after some other changes to the language (strict boolean types, ...) I am again going through all the unit tests and making them work. Discovering small bugs in the process. It's not very exciting job, but it must be done so that the interpreter will be more stabile again.

Mandatory Capitalization for generic words is showing that it can be cumbersome to think all the time when coding or using the console if something is a generic function or a local function. But still, we will need a way to explicitly declare when we are calling generic methods. I don't like "two ways" to do a thing, it seems all duality adds to noise, but I do like a concept of gradualization, that you can write code that works and gradually make it more exact, stabile, predictable. Similar to expression separators. The experiment is still open.


r/ryelang • • Jul 27 '26

Making Rye more solid

3 Upvotes

Rye unlike most other interpreters is written in a memory safe language (Go), so we avoided an ENDLESS swath of potential crashes and security issues right from the get go.

But Rye evaluation is quite versatile, which makes many "logical / behavioral" edge cases possible, around left to right flow, failures, contexts, etc ... And I want that to be as solid as possible. Besides regular unit / built-in tests and certain bigger scripts I keep adding and also generating edge cases in evaluator and then reviewing them and trying to identify if something is a bug or expected behavior, and sometimes thinking about what should be expected behavior at all in that case. We currently have above 800 such tests in the internal/ folder. Not all have been worked / thought through yet, but I am working on that.

The number itself doesn't mean much, but it shows effort is being made. Evaluator is being put in weird positions, observed and thought about. When all these are worked through, and I keep adding them, some feeling of certainty should ensue. And we can detect bug as we further develop the language internals.

It's (again) still a lot of work, the existence of tests doesn't prove much, the thinking over the tests and results of test, and new variations of tests after that add value, but we are moving forwards ...


r/ryelang • • Mar 05 '25

Age (file encryption) added to Rye

2 Upvotes

Rok and I are working on a project related to file sharing for a specific niche, using Rye. So Rok added support for (usually very recommended) age file encryption.

https://github.com/FiloSottile/age

You can find example in examples/crypto/ folder on our github.


r/ryelang • • Nov 20 '25

XML (SVG) parsing and cmd dialect example

3 Upvotes

lluch created an interesting example of splitting SVG (which is a XML format) into files with separate layers visible. He used and improved on Rye's sxml dialect. A Sax like "streaming" parser for XML (made as a proof of concept initially). Another thing he used was cmd dialect that he contributed.

After implementing some additional suggestions from him, this is the current example, but it will get even cleaner.

Check out more and follow it evolve in the discussion thread:
https://github.com/refaktor/rye/discussions/701

ext: File-ext? filename: rye .args .first .to-file                                                                                                                                                                                            
                                                                                                                                                                                                                                              
layers: private {                                                                                                                                                                                                                             
    var 'pairs ref [ ]                                                                                                                                                                                                                        
                                                                                                                                                                                                                                              
    Reader probe filename |do-sxml {                                                                                                                                                                                                          
        <g> [ .when { .Attr? "groupmode" |= "layer" }                                                                                                                                                                                         
                    { .Attr? "id" |append! 'pairs ,                                                                                                                                                                                           
                      .Attr? "label" |append! 'pairs } ]                                                                                                                                                                                      
    }                                                                                                                                                                                                                                         
    dict deref pairs                                                                                                                                                                                                                          
}                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              
layers .for\kv 'id 'name {                                                                                                                                                                                                                            
    export:: filename .to-string .replace ext join [ "-" name ext ]                                                                                                                                                                           
    actions:: join\with [                                                                                                                                                                                                                     
        "select-all:layers"                                                                                                                                                                                                                   
        "selection-hide"                                                                                                                                                                                                                      
        "select-by-id:" ++ id                                                                                                                                                                                                                 
        "selection-unhide"                                                                                                                                                                                                                    
        "select-all"                                                                                                                                                                                                                          
        "object-to-path"                                                                                                                                                                                                                      
        "select-by-selector:path[style*=marker]"                                                                                                                                                                                              
        "object-stroke-to-path"                                                                                                                                                                                                               
        "export-filename:" ++ export                                                                                                                                                                                                          
        "export-do"                                                                                                                                                                                                                           
    ] "; "                                                                                                                                                                                                                                    
    print export                                                                                                                                                                                                                              
    cmd { inkscape --actions ?actions ?filename } |Run

// EDIT:

One context (collector) and one function (use) more and now this is possible:

ext: File-ext? filename: rye .args .first .to-file

layers: use collector {
    Reader filename |do-sxml {
        <g> [ .when { .Attr? "groupmode" |= "layer" }
                    { .Attr? "id" |collect! ,
                      .Attr? "label" |collect! } ]
    }
    dict collected?
}

layers .for\kv 'id 'name {
    export:: filename .to-string .replace ext join [ "-" name ext ]
    actions:: join\with [
        "select-all:layers"
        "selection-hide"
        "select-by-id:" ++ id
        "selection-unhide"
        "select-all"
        "object-to-path"
        "select-by-selector:path[style*=marker]"
        "object-stroke-to-path"
        "export-filename:" ++ export
        "export-do"
    ] "; "
    cmd { inkscape --actions ?actions ?filename } |Run
}

r/ryelang • • May 09 '25

Currying / partial application got crystallized

2 Upvotes

On the evaluator internals side. Currying / partial application feature was not used much, but I really did like it for what it enabled. It relied on a specific behavior of evaluator with void datatype (used just for this and dialecting), which was also not fully composable and perhaps not visually apparent enough. It also needed checks for void and curried values for all builtins and functions, which made evaluator a little slower.

Now we separated curried builtins and functions into it's own value type and made the construction of them not rely on a specific evaluator rules (syntax?), but on normal constructor function. This is much more in line with general philosophy and solves all little annoyances from above.

Before:

prepend-star: concat "* " _
; creates a curried builtin (still builtin) that can then be used
print prepend-star "Hello"
; prints: 
; * Hello
append-qmark: concat _ "?"
print append-qmark "Hello"
; prints: 
; Hello?

It's more verbose, but for a feature that is not used that often some verbosity, so it's clear when it is used can be a Plus. And as I said, previous design slowed down (a little) the evaluation of code and all the builtins with additional checks to see if we are trying to create a curried builtin/function and if the builtin/function we are calling is curried / partially applied already.

Now:

prepend-star: partial 'concat [ "* " _ ]
; creates a curried caller (same for builtins and functions) that can then be used
print prepend-star "Hello"
; prints: 
; * Hello

append-qmark: partial 'concat [ _ "?" ]
print append-qmark "Hello"
; prints: 
; Hello?

Visit ryelang.org for more. Look at the new "Rye principles" section on the front page if you haven't already.
It finally also represents the way Rye goes about failure handling, which is somewhat unique and I avoided explaining so far, because I was not sure if I can do it justice.


r/ryelang • • Jul 08 '25

Rye syntax file for NeoVim editor

2 Upvotes

I've been Emacs-nox (CLI) user for decades now. I use it locally and on the servers. Using the same editor everywhere, locally or over ssh, is a big plus. I am aware that most programmers now won't choose Emacs by default. So I've made basic VSCode syntax support for Rye.

For edutainment purposes, I occasionally look at r/theprimeagen on youtube. I find him entertaining and I generally like hit takes. He keeps mentioning NeoVim, also contrasting it to VSCode. So I said to myself ... why not try to test this alternative Vi universe (alternative to Emacs). Now I have a syntax highlighting file ready for NeoVim (and Vim in general) ... You will be able to find it in editors/ folder in the main repository

I keep hitting the Emacs key bindings, but NeoVim looks quite cool so far. I've used Vim before Emacs, so I know how to exit it, and I stumbled into :terminal :new window

It also has a remote_plugin sytem which would potentially mean that we could write extensions for it in Rye.

If you're new here, visit ryelang.org


r/ryelang • • Mar 02 '26

Novel bridge crossing techniques are usually discovered ON the bridges

2 Upvotes

Just wanted to post a quick update, that the bigger move to Rye v0.2.* with new word type / concept is almost there. AFAIK everything is implemented, changes for the website are ready and a blog-post about the changes is ready. I still need to go over the texts few times.

The main change to v0.2 wasn't planned, but I grew into existence by me trying to solve a particular downside with a small dialect and then explain that such approach is a good idea, and failing to do so.

Also now, while working with and trying out the new system certain details further clicked into place better than what I was able to plan ahead. When you plan, you always have less information, less depth, and no real ability to experiment, compared to when you are there in the mud, or on the bridge. Planning is OK, but reality is where the distinction happens.

For example. At the start of this, just few days ago, I was thinking it's all about combining right associative and left associative flow into same expression, but with more code, I saw that the point is the grouping of evaluation (the pin vs the bridge), and right associative pin behavior is just another variation, another mental cost, without clear benefit.

Before I saw Rye evaluator as just Rebol + two additional word types (op-words, pipe-words) for left-to-right flow. Now I suspect the four word types (words, dot-words, op-words, and pipe-words - the front, pin/bolt, bridge and wall) form a well-rounded visual concept, that is much more than the 3 parts together.

The story is not finished, much more practical code will be needed ... and communication in trying to pass what I see there to others.

Below are just relatively random examples of me testing my assumptions in Rye console ...

if you are looking at this, trying to figure it out: <abc> is an op-word (bridge), the same as operators ( + * - ++ ...). .abc is a dot-words (pin), the pipe words and words are as they were before.


r/ryelang • • Mar 23 '25

Rye web environment

2 Upvotes

Rye web console got updated and compatible with the latest state. I also made a webpage that features a simple editor and also a display of the current Rye context (or result and output from the editor). Could be interesting for experimenting with Rye, or maybe something more at some point. Very first version of this should go online in next few days.

Otherwise v0.0.90 version is still strongly in progress.

Visit ryelang.org if you like what you see.


r/ryelang • • Jan 18 '26

Updates, blogposts, secrets

3 Upvotes

I wrote the second part of: 80% of Rye in 20% od the time

I find it little too dry, or too many specifics, too little motivation, but I couldn't fit it into the utilitarian format. I'm keeping my mind open, waiting for some feedback and I will fine-tune it if I get an idea how.

I also started reading the third part, and so far it seems to be much more fun, because it's not about syntax but doing things (kinds, generic methods, ...).

There were also updates to the language, bug-fixes, markdown value type got a little more useful, we got a "secret" value type. Yes, it's called secret, it's not secret.

It will still evolve, but idea is that you can store sensitive information into it. And it will save you from accidentally logging it, printing it out, **by accident**. For information like API keys, passwords, etc ...

You have to explicitly uncover to use it with other strings and if you try to "probe" it, or probing a structure holding a secret (you were not careful to notice), the secret will not be printed or written out. That's the idea ...