New week, new Rust! What are you folks up to?
Still working on https://github.com/svenstaro/miniserve
So, miniserve is a self-contained cross-platform CLI tool that allows you to serve some files via HTTP.
It now features:
- folder download (*)
- file upload
- basic auth
- random route generation
- file sorting
- and it has some nice themes
You may drop SimpleHttpServer now
(*): on this aspect, we’re actively looking for a crate that would allow to compress a filesystem entry and STREAM the result. Whatever the compression algorithm, pure Rust implementations preferably though. We’re currently using tar-rs, yet it’s not really convenient as it builds the whole archive before returning it. Thank you
Got a number of collision improvements working:
- Hit delay: When collision happens, character hit animation pauses.
- Hit limit: A character can only hit up to N other characters (e.g. punch can hit only 1 other character, power move can hit multiple characters).
- Hit repeat: Cooldown period before the attacking character can re-hit the same hurt character.
Now working on separating sequence transitions for input events vs input state (i.e. key-press vs key-hold).
Preliminary tests show 10-25 times speed up on a tight load loop if the caching can be used.
Starting to slowly work towards a 0.3 release of my 2D game library Tetra, but that requires me to make actual API decisions
So I’m procrastinating by revisiting my old programming language project Ein - it now uses a basic stack VM instead of a treewalk interpreter, and I’ve gotten it executing basic expressions
Rho, a new/renewed language design project of mine, and my first experience at designing and developing a programming language. Aims to provide for Rust what Lua provides for C - a highly-integrated, lightweight scripting language. I mainly plan on using it as a scripting API within a game engine.
Here are some of the things that I chose specifically for this design:
A simple set of types. The primitives are nonetype, bool, int, float, bytes, string, function, and type. Only compound types are list and table (no custom / named types at the moment).
Dynamic typing, but with strict coercion rules on operations (no weird “5” + 3 cases allowed here).
Reference-free data - all values are copied around from the perspective of the language itself (though heap-allocated items are usually reference-counted in the background).
Patterns, a way to conditionally match and unpack compound types.
Function definitions based on lambda calculus (Haskell).
Interop with Rust APIs: functions whose parameters/return values can be converted to Rho values can be called just like any function defined within Rho. I might be able to do something with procedural macros to generate wrappers around such functions, which would be fun to learn and implement.
Compile-time interpretation of Rho expressions using proc-macro-hack (still highly experimental but would be cool)
This is still very much WIP, but I don’t think I’ll be changing these basic concepts any time soon. Repository at https://gitlab.com/tsukurou/rho is soon to be populated, if you want to follow it or contribute.
Still hacking on and testing on more-interesting.
Mostly trying to focus more on user feedback than code cleanliness and optimal performance, but now that it’s actually getting some use, I’ve started trying to figure out how to make diesel stream my rows. Also, of course, trying to get somewhat less repetitive diesel code.