sinisterMage

this looks very cool! however from what I've seen in your repo, security features are not implemented yet right? if I am right, I would recommend to implement them as soon as possible as you don't want someone random accessing development apps, but very cool regardless, keep up the good work!

oh alright! very understandable :) good luck with this project!

this seems very impressive! however i would like to ask, why the language choice of go? and not something like elixir for fault tolerance and its actor model, i am asking not because i dont like go, i am simply curious

thank you, I really appreciate that

thank you for the kind words :)

Thanks!

Yeah, I totally get that! W++ isn’t meant to copy Python’s syntax exactly — instead, the inspiration from Python is in its simplicity and low barrier to entry.

I drew from multiple languages — Python, JavaScript, even a little C-style flavor — to make something that’s readable, expressive, and beginner-friendly, especially for quick scripting in .NET.

Appreciate the suggestion! I’ll make sure the SYNTAX.md is linked more clearly from the README.

Totally fair! I know semicolons aren’t for everyone — W++ leans into a mix of familiar C-style syntax with some Python-style simplicity, but it’s definitely not a perfect fit for all tastes.

Appreciate the kind words regardless — and who knows, maybe I’ll experiment with optional semicolons in a future version.

Yeah, so here’s the full story: when I first uploaded the W++ VSCode extension to the Marketplace, it took off faster than I expected — over 33,000 downloads in under 2 hours. A few days later, it was suddenly removed.

Only later did I find out it had been labeled as malware by Microsoft — no details, no warning. I emailed their support to clarify what triggered the flag, but I never got a response.

Since then, I’ve made the entire source public here, including the VSCode extension, so folks can inspect and use it freely. If anyone has experience navigating these kinds of takedowns, I’d definitely appreciate insights.

You're totally right to catch that — I’ll update it for clarity!

The idea was: W++ aims for a syntax that feels lightweight like Python (minimal boilerplate, indentation structure), but it also borrows C-style flow and expression flexibility. So technically it’s a bit of a hybrid:

Block structure + minimalism = inspired by Python

let, const, switch, and lambdas = more JS/C-style

I’ll clean up SYNTAX.md and the description to better reflect that. Appreciate you pointing it out!

Yep, W++ lambdas are statement-level on purpose My high school teacher once told me lambdas are “university-level,” so I made them the default function syntax in W++. It’s my way of saying: “nah, these aren’t scary — they belong in scripting too.”

That said, I totally agree that full anonymous functions would be useful (especially for more complex logic). Might explore adding those later, but I love the message the current model sends.

Thanks for the thoughtful feedback — you raised a few great points I hadn’t fully considered.

You're absolutely right about JIT startup time. Currently, W++ doesn't do any caching or ahead-of-time work, so there’s a delay on the first run. I’ll explore ways to keep it snappy for quick scripts — maybe a pure interpreter fallback for single-run use cases would help.

Also appreciate the insight on the Python comparison. That “in-between state” you described is exactly where I’m at — trying to blend Python’s simplicity with .NET’s power. But you’re right, the messaging could be cleaner. I’ll adjust the README to better reflect that W++ is its own thing and not a direct clone or pitch to Python devs.

This kind of comment is gold, seriously. Thanks for taking the time.

Totally fair question — most high-level languages do take care of memory for you, especially with garbage collection.

But in hosted scenarios like IronPython or W++ (where the language is layered on top of .NET), things can get trickier:

You're managing your own object model inside a host runtime.

If you're not careful, it's easy to create long-lived references (like global caches or circular structures) that the GC won’t clean up.

In IronPython's case, hosting decisions (like how objects interop with .NET classes) can leak unintentionally if lifecycle logic isn't airtight.

So yeah — you usually don't think about memory... unless you're writing the language

Haha yeah, fair point on the name! I actually chose “W++” from a gaming mindset — in games, W = Win, so W++ was my way of saying "keep stacking wins." It’s not meant to compete with Rust or Zig — it’s more of a light, expressive scripting language that happens to be built on .NET.

But you’re totally right that naming is tricky. I might reconsider down the line if it ever gets serious traction — “Cobra” does sound kinda slick

Appreciate the feedback!

Thanks! I really appreciate you taking the time to write this up — super insightful.

I definitely get the appeal of internal DSLs, especially with how powerful C#’s fluent APIs have become. W++ takes a bit of a different path: more like “what if .NET had a native scripting layer that felt expressive and lightweight,” even if that means giving up some safety or flexibility of the host language.

And wow — 3 years with IronPython is no joke. Totally agree on how tricky it can get once you step outside the intended boundaries. I’m keeping W++ focused more on smaller, experimental scripting for now, but your point about memory and lifecycle management is a great reminder for anything that gets more ambitious.

Cheers for the link to Fowler’s DSL article too — gold.

Thanks! Totally fair — I know significant indentation and dynamic typing aren’t for everyone.

W++ leans that way just to reduce boilerplate and keep the syntax clean for smaller scripts, but it’s not trying to be the “one true way” to write .NET code. Honestly, it’s all about exploring what a lightweight .NET scripting layer could feel like.

Appreciate you checking it out

That’s a really cool idea — a “Clojure of .NET” would definitely fill a unique niche. W++ kind of stumbled into this space by aiming to make .NET feel more like Python for scripting — but yeah, I’d love to explore where it could go if more folks want something expressive but tightly integrated with .NET.

Also, totally agree — bridging Python and .NET ecosystems more deeply (like Django with NuGet access ) sounds wild and fun. Appreciate the thoughts!

Totally fair point — W++ isn’t meant to be a direct Python clone, just inspired by its simplicity and clean syntax (like indentation and dynamic typing). The goal was to make scripting on .NET feel lighter and more approachable.

I’ll tweak the README to make that clearer. Appreciate the honest feedback!

Oh wow, I actually hadn’t heard of Boo until now — thanks for sharing it! Just took a quick look and yeah, I can definitely see some parallels. W++ wasn’t directly inspired by it, but I guess we both arrived at similar goals: a Python-style language that plays well with .NET.

Thanks! That means a lot

W++ doesn’t have full-blown data flow analysis (yet!) — the current interpreter walks the AST in a fairly straightforward way, and the JIT just compiles expression trees without SSA or optimization passes. But your idea of analyzing LLM-generated scripts is super interesting. I'd love to explore basic flow inference or a visualizer in the future.

Feel free to open an issue or discussion if you’re curious — would be awesome to collaborate!

You're totally right to ask — W++ borrows Python’s general feel (like significant indentation and dynamic typing), but its core is rooted in a C-style heritage due to the .NET foundation. So while let and semicolons aren’t Pythonic, the language avoids boilerplate, supports clean control flow, and aims for the readability people love about Python.

I’ll make the README clearer with a side-by-side W++ vs Python snippet to highlight the similarities better. Thanks a lot for pointing it out!

You're absolutely right — IronPython does run Python on .NET.

W++ takes a different approach: it's a custom scripting language that looks like Python but is designed for tight integration with .NET itself, including:

Native JIT compilation (via IL emission)

NuGet package import support (via .ingot wrapping)

Familiar syntax (like print, let, for, if) with static structure

IronPython is about bringing Python to .NET. W++ is about making .NET scripting feel more like Python.

Think of it as IronPython’s minimalist, compile-time-powered cousin.