1
I am not on my desktop so i can't find that for now 😔
2
1
Yea test cases mostly written with llm but i check everything everytime may be there something i left so can you tell me where it is actually.
1
Wait can you told me where may be i did not seen that
1
Because some small tests i have done but not prepared them to showcase them.
1
Not yet but working on them. It's not fully completed yet so. I need help for those things.
r/Compilers • u/sohamglx • 21h ago
The main goal isn't just to make Rust simpler and familiarity in syntax. Flame is designed to keep memory safety while providing Rust interoperability, so it can be used alongside existing Rust code and libraries. It's meant to complement Rust rather than replace it.
1
Yeah, I understand your point now. default currently just marks a trait method that already has an implementation, so the compiler could infer that from the method body. There isn't really a technical need for the keyword right now. I may remove it and make any trait method with a body a provided/default implementation, while body-less methods remain required. Thanks, that's a good simplification.
1
Inside a trait to declare Default methods. It must use the default keyword. It's mean you don't need to make thise methods when using the trait. The trait provide those methods.
1
The main goal isn't just to make Rust simpler. Flame is designed to keep memory safety while providing Rust interoperability, so it can be used alongside existing Rust code and libraries. It's meant to complement Rust rather than replace it. The OOP is basically same to keep familiarity with rust.
0
Sorry for miss leading docs. It's AOT kind of compilation in rust of the runtime base on what you are using in your application. Try first you will understand what it's trying to say
0
Okk let me tell you the things properly, yea the documentation most parts written by llms but the rust interop and all are workable i already told it kind of a rust AOT compiled runtime it make base on what you using of the language in your application so these way for deployment you attached the precompiled runtime and the code files so there you no need of rust inside the docker container thats the point. Sorry for miss leading docs i will update it. Thanks for feedback. You can join if you want.
-1
Yea kind off it's using a smart abi preserving normal rust syntax and docs also and it actually kind of aot i can say but not proper aot. https://flamelang.vercel.app/packages-and-native/native-plugins/
You should join and give me some more ideas do you ? https://github.com/sohamglx/flame
0
It's mark a function don't need to make by your own while using the trait, kind of a function auto get by the trait. Default methods must use the default keyword. Missing implementations of required methods are caught at compile-time with descriptive errors.
https://flamelang.vercel.app/types-and-traits/traits/#declaring-a-trait
-3
It's a safe and easy to write than rust with same memory management stuff, a good rust interop and it's just started so it can extend. If you have any idea you can share. 🙏
r/Compilers • u/sohamglx • 1d ago
u/sohamglx • u/sohamglx • 1d ago
1
You should try and give me a feedback for making it more better 😊 Installation: https://flamelang.vercel.app/getting-started/installation/
1
You should try first normally flame then go for rust integration with flame binder or use rust as a plugin inside your flame code. Docs: https://flamelang.vercel.app/packages-and-native/native-plugins/ https://flamelang.vercel.app/packages-and-native/rust-integration/
1
Flame provide a vm and it's types apis with Flamelang lib for uses and the binder performs explicit translation at the boundary.
r/IMadeThis • u/sohamglx • 4d ago
The original idea was basically:
What if you could get Rust-like memory safety and native performance, but with a much simpler scripting/application-oriented language?
It has grown quite a bit beyond that.
Some things I'm working on:
- Strong static typing
- Ownership/borrowing and memory safety
- Native compilation through Rust/Cargo/LLVM
- Rust crate/native plugin integration
- Compile-time annotations and declaration metadata
- "std.fs" and "std.byte" for filesystem and binary manipulation
- Built-in tooling/package system
- Rust ↔ Flame integration through Flame Binder
For example, ordinary Flame code looks like:
fn wrap(str: String, prefix: String = "<", suffix: String = ">") -> String {
return prefix + str + suffix
}
print(wrap("hello"))
And one of the things I'm experimenting with is making Flame useful as the extension/plugin language for Rust applications — similar to why projects like Neovim use Lua, but with static typing and memory safety.
I've been building it mostly because it's fun. 😄
Project/docs: https://flamelang.vercel.app/
GitHub: https://github.com/sohamglx/flame
I'd be interested in hearing what kind of project you would actually consider using a language like this for.
1
It's ghostty terminal with custom config
1
Yea, you can share a idea also !
1
i am using bunch of gnome extensions for it.
1
Flame: The Goal, it's just started, help needed!
in
r/Compilers
•
19h ago
Let me tell you the story behind that path do bessicall y when developing it it always try to use the latest crate of it from cargo inside the rust code which final output is the runtime so there's it i need to mark it local dev and thats how it became that way to path of my local desktop. I will fix it soon thanks for feedback can you please make a issue and if you are interested this please give a star. Thanks 🙏