One thing I miss here (and admittedly I only skimmed through the post so if I missed this, please do correct me) is "ad hoc" unions.

It would be great to be able to do something like

  public Union GetThing()...

I'm calling it Wisp.

The main motivation was frustration with some aspects of ASP.NET, especially the requirement to target the Web SDK instead of the base .NET SDK. That makes embedding small HTTP apps inside existing applications harder than it should be since it forces you to pollute your scope with the Web SDK.

I also don't like CSHTML/Razor and wanted a more traditional templating language.

Wisp is a relatively lightweight MVC framework built without any dependencies on the .NET Web SDK.

Some highlights:

  - Runs on the base .NET SDK (no ASP.NET dependency)
  - Traditional MVC controllers
  - Dependency injection via Microsoft.Extensions.DependencyInjection
  - Configuration via Microsoft.Extensions.Configuration
  - Templating via the Fluid engine (Liquid-compatible)

The code is written by hand, not vibe-coded.

If you're interested in experimenting with alternative approaches to building web apps in .NET, feedback and contributions are very welcome.

Docs: https://wispframework.github.io/Wisp/

Quick start:

  dotnet new install Wisp.Framework.Templates
  dotnet new wisp.mvc
  dotnet run

  var hostBuilder = new WispHostBuilder();
  hostBuilder.UseStaticFiles();

  var appBuilder = hostBuilder.Build();
  appBuilder.UseControllers();

  var app = appBuilder.Build();
  await app.RunAsync();

Comments URL: https://news.ycombinator.com/item?id=47245656

Points: 2

# Comments: 0

Edit: The status page is no longer green

https://github.com/WispFramework/Wisp, https://wispframework.github.io/Wisp/

It tries to be reasonably lightweight but batteries-included, with extra features in separate "extensions" packages. It's also designed to be modular. All functionality has a default implementation but can easily be replaced if desired. It uses the Fluid template engine[1] (a .NET implementation of the Liquid language).

It's been a great way to dig into more advanced concepts like reflection and HTTP internals and while it's probably not safe to use in production, I have used it to build small private apps with great success.

The current major pain points are the lack of websocket support, which I'm planning to add soon, and the general fragility of the NetCoreServer[2] based HTTP backend, which I'm planning to replace with EmbedIO. (Ideally, I would love to use Kestrel here, but it's so deeply baked into ASP.NET Core that you can't use it without pulling in the whole Web SDK)

The documentation is also pretty incomplete but I hate writing docs so I find it hard to force myself to do it.

[1] https://github.com/sebastienros/fluid

[2] https://github.com/chronoxor/NetCoreServer

(LLM Disclaimer: This project is not vibe-coded. Most of the code is written by hand, with some input from ChatGPT being used as a fancy search engine. The docs are written by hand and then fed through ChatGPT to make them more readable)

(not affiliated with the project, just really want to see it succeed)

[1] https://stoat.chat/ [2] https://github.com/stoatchat/for-ios

* Is that what it's called? The top part that goes over your head...

$275,000 is almost $23,000 a month. Take that times N amount of employees, and other business overhead, and suddenly $80k a month is literally peanuts.

[1] https://tailwindcss.com/blog/hiring-a-design-engineer-and-st...

  #!/usr/bin/env dotnet run
  #:package Newtonsoft.Json@13.0.3
  
  using Newtonsoft.Json;
  
  Console.WriteLine(
    JsonConvert.SerializeObject(new { Hello = "world" })
  );

  #!/usr/bin/env dotnet run
  #:sdk Microsoft.NET.Sdk.Web
  
  WebApplication
    .Create()
    .MapGet("/", () => "Hello from a shell script!")
    .Run();

[1] https://keropunkgame.com/