<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    
    <title>Daniel Cazzulino</title>
    
    
    <link>https://www.cazzulino.com/</link>
    <atom:link href="https://www.cazzulino.com/feed.xml" rel="self" type="application/rss+xml" />
    
    
      <item>
        <title>Bitcent: The 10⁻¹⁰ Dollar Unit for AI Pricing</title>
        <description>
          
          I’ve been playing with the xAI API recently, and noticed something interesting about their pricing model. The API returns usage costs as integers, but the numbers didn’t immediately make sense. For example, a Grok Imagine generation costs 330,000,000. On their pricing page, that lists as $0.033. Or take grok-4-1-fast-reasoning, which returns prices like: &quot;promptTextTokenPrice&quot;: &quot;2000&quot;, &quot;cachedPromptTokenPrice&quot;: &quot;500&quot;, &quot;completionTextTokenPrice&quot;: &quot;5000&quot; Represented as follows on the Models page: Input: $0.20 Cached input: $0.05 Output: $0.50 Doing the math, that means each unit is 1/10,000,000,000 (one ten-billionth) of a dollar ($10^{-10}$). I needed a name for this conceptual unit to keep things sane,...
        </description>
        <pubDate>Fri, 09 Jan 2026 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/bitcent.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/bitcent.html</guid>
      </item>
    
      <item>
        <title>Streamlining Remote C# Scripts with .NET 10 runfile</title>
        <description>
          
          TL;DR: Run remote scripts instantly with the ref format [host/]owner/repo[@ref][:path]. dnx runfile kzu/run:clean.cs With .NET 10, we are seeing continued improvements in how we can run C# code directly. The new runfile feature allows for a more streamlined execution of local C# files, making it easier than ever to treat C# as a scripting language. The Problem: Sharing Scripts However, what if your scripts aren’t local? What if you want to share useful utility scripts across your team or the world without requiring everyone to clone a repository or copy-paste code? Enter the runfile global tool. The Solution: dnx runfile...
        </description>
        <pubDate>Wed, 19 Nov 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/running-remote-csharp-scripts.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/running-remote-csharp-scripts.html</guid>
      </item>
    
      <item>
        <title>SponsorLink is dead: long live OSMF</title>
        <description>
          
          Almost exactly a year after my SponsorLink v2 post, and having virtually no traction whatsoever (besides a handful of sponsors, deeply appreciated!), I’m announcing its retirement and replacement with a new approach: the Open Source Maintenance Fee (OSMF). This approach is currently being successfully used by WiX Toolset. You can listen to this .NET Rocks episode where Rob Mensching discusses it in detail. Please read his Introducing the Open Source Maintenance Fee post for more context, as well as his Open Source Maintenance Fee Two Months In where he shares his experience and reception by the community. I’m not going...
        </description>
        <pubDate>Thu, 16 Oct 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/osmf.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/osmf.html</guid>
      </item>
    
      <item>
        <title>dotnet actions: C# scripting to the rescue</title>
        <description>
          
          What a monumental release for .NET scripting is .NET 10! The long journey that started with C# 9 top-level programs has finally culminated in a full-fledged scripting experience that leverages the entire .NET ecosystem in .NET 10: File-based apps go beyond just C# statements and now supports #:sdk, #:package and #:property directives that allow the full breadth of .NET SDKs and NuGet packages to be used in scripts without the need for a project file. SmallSharp is a tiny NuGet package / MSBuild SDK that teaches Visual Studio how to edit multiple file-based apps in a single project, using the...
        </description>
        <pubDate>Thu, 04 Sep 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/dotnet-actions.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/dotnet-actions.html</guid>
      </item>
    
      <item>
        <title>VSCode shipping cadence: AI coding is real</title>
        <description>
          
          I started playing with the MCP C# SDK soon after it came out, and soon realized that there was a gap in functionality: setting the log level in the MCP server-specific output pane in VSCode was not invoking my MCP server’s corresponding log-level change handler. So I naturally opened an issue in the VSCode repo and even provided some context that Copilot gave me about where the potential issue was and how to fix it. I didn’t go as far as providing a PR, and a friend on X even challenged me to do so. A few days went by,...
        </description>
        <pubDate>Sun, 27 Jul 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/vscode-copilot.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/vscode-copilot.html</guid>
      </item>
    
      <item>
        <title>SmallSharp 2.0: The End of ConsoleApplication128</title>
        <description>
          
          SmallSharp 2.0: The End of ConsoleApplication128 The New Era: dotnet run app.cs With .NET 10, you can now run a single C# file directly: dotnet run app.cs No project file, no ceremony. Just write your code and go. You can even add NuGet packages or MSBuild properties right in your .cs file: #:package Humanizer@2.14.1 #:property LangVersion=preview using Humanizer; var dotNet9Released = DateTimeOffset.Parse(&quot;2024-12-03&quot;); var since = DateTimeOffset.Now - dotNet9Released; Console.WriteLine($&quot;It has been {since.Humanize()} since .NET 9 was released.&quot;); For more, check out Microsoft’s announcement. The Problem: One File, Limited Experience While this is a huge leap for C#, editing these files...
        </description>
        <pubDate>Tue, 22 Jul 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/smallsharp.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/smallsharp.html</guid>
      </item>
    
      <item>
        <title>How to use Grok 4 without SuperGrok subscription</title>
        <description>
          
          Grok 4 was just announced and it looks incredible. So you want to try it out, but are hesitant to shell out $300/year for the subscription just to try it out. Here are the steps to use it daily without limits, without breaking the bank: Go to OpenRouter, create an account, get an API key and add some credits Open VS Code (insiders recommended) and run the “manage models” command (Ctrl+Shift+P, type manage models): Select OpenRouter: Enter the API key you got from 1: Select xAI: Grok 4: After these changes, you can now open the GitHub Copilot window by...
        </description>
        <pubDate>Fri, 11 Jul 2025 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/grok4-vscode.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/grok4-vscode.html</guid>
      </item>
    
      <item>
        <title>Consuming VSIX metadata from C#</title>
        <description>
          
          Sometimes it’s useful to render VSIX manifest metadata in logs, or some UI in your extension. You could just duplicate the values in your code, but that’s error-prone and tedious. The ThisAssembly.Vsix package can help you avoid that by generating a ThisAssembly.Vsix class with all the metadata from your VSIX manifest. In addition to making the VSIX manifest metadata properties available as constants, the package also provides targets for those properties with sensible defaults from project properties so that the manifest can leverage placeolder syntax and avoid duplication in the source.extension.vsixmanifest: &amp;lt;PackageManifest Version=&quot;2.0.0&quot; ...&amp;gt; &amp;lt;Metadata&amp;gt; &amp;lt;!-- You can use the...
        </description>
        <pubDate>Fri, 08 Nov 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/thisassembly-vsix.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/thisassembly-vsix.html</guid>
      </item>
    
      <item>
        <title>Typed chat completions with OpenAI and .NET 9</title>
        <description>
          
          TLDR: grab the source code or add it locally with dotnet file add https://github.com/devlooped/catbag/blob/main/OpenAI/Chat/ChatClientTypedExtensions.cs . (leveraging dotnet-file). Open AI recently introduced support for structured outputs in the API, and the final stable release of the .NET API for it released a mere 9 days ago has full support for leveraging that. By then, a post on X by David Fowler on a new JsonSchemaExporter made total sense (and I’m sure something official is coming down the pipe soon for the official SDK). So I set out to try combining all things together in a simple extension method: var client =...
        </description>
        <pubDate>Wed, 09 Oct 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/typed-chat.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/typed-chat.html</guid>
      </item>
    
      <item>
        <title>Showcase your NuGet package stats with fancy badges</title>
        <description>
          
          As part of developing SponsorLink v2 I needed a mechanism to determine what packages in nuget.org were popular (in terms of daily downloads), as well as their source repositories and contributors. This is not readily available from NuGet itself. What I’ll show you here is what powers the OSS Authors page, where you can lookup arbitrary GitHub accounts (user or organization) and see what packages they contributed to, as well as the daily download stats for those packages. The way it works is three-fold: Scrap a static JSON file from nuget.org with the relevant package stats. Host that JSON file...
        </description>
        <pubDate>Wed, 09 Oct 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/nuget-stats.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/nuget-stats.html</guid>
      </item>
    
      <item>
        <title>SponsorLink v2: A New Hope</title>
        <description>
          
          Almost exactly a year after my SponsorLink feedback post, I think I have worked out most of the issues and would like to give this another try with a completely rewritten SponsorLink v2. A lot has happened in the intervening year, including valuable experiences trying to monetize OSS by other popular libraries (like ImageSharp, PrismLib and others). Many things stayed the same, though, including pitiful sponsoring uptick since I removed all traces mentioning the ability to sponsor my libraries from build and analyzer tools. Just as last time, an obvious disclaimer first: I’m not speaking for anyone but myself. I...
        </description>
        <pubDate>Tue, 08 Oct 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/sponsorlink2.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/sponsorlink2.html</guid>
      </item>
    
      <item>
        <title>Condition xunit tests to presence of user secrets</title>
        <description>
          
          Sometimes you need some API keys, connection strings and the like in order to run your tests. If you’re using user secrets, which is highly recommended, you can share your secrets with your tests quite easily by moving the UserSecretsId MSBuild property to a Directory.Build.props. In order for tests to be skipped automatically if the required secrets aren’t present, you can create custom fact and theory xunit attributes, such as: public class SecretsFactAttribute : FactAttribute { public SecretsFactAttribute(params string[] secrets) { var configuration = new ConfigurationBuilder() .AddUserSecrets&amp;lt;SecretsFactAttribute&amp;gt;() .Build(); var missing = new HashSet&amp;lt;string&amp;gt;(); foreach (var secret in secrets) { if...
        </description>
        <pubDate>Mon, 07 Oct 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/secrets-tests.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/secrets-tests.html</guid>
      </item>
    
      <item>
        <title>Deploying dotnet-isolated function app from CLI</title>
        <description>
          
          Whether you’re creating a brand-new .NET isolated function app or migrating an existing one, if you’re deploying it using the Azure Functions Core Tools, you might encounter this error: Your Azure Function App has &apos;FUNCTIONS_WORKER_RUNTIME&apos; set to &apos;dotnetIsolated&apos; while your local project is set to &apos;dotnet&apos;. You can pass --force to update your Azure app with &apos;dotnet&apos; as a &apos;FUNCTIONS_WORKER_RUNTIME&apos; The suggestion would do the exact opposite of what we want to achieve! There is an undocumented flag --dotnet-isolated that you can use to specify the dotnet worker runtime, which combined with --force will ensure the app is updated to...
        </description>
        <pubDate>Sat, 17 Aug 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/func-dotnet-isolated.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/func-dotnet-isolated.html</guid>
      </item>
    
      <item>
        <title>Beautiful dotnet test summary reports</title>
        <description>
          
          Running tests across multiple projects in a solution doesn’t have to look like the 90s in today’s console. Now you can use a simple dotnet global tool to get an intuitive glimpse at what happened with that last test run that resulted in gazillion lines of text :) TL;DR;: Install: dotnet tool install -g dotnet-trx Run: dotnet test -l trx; trx The out-of-the-box reporting on test run results in dotnet is at this point an embarassment. So I set out to build something for myself that brought back some joy in running tests from the console. The result is a...
        </description>
        <pubDate>Sat, 17 Aug 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/dotnet-trx.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/dotnet-trx.html</guid>
      </item>
    
      <item>
        <title>How to run dotnet tests with automatic smart retry</title>
        <description>
          
          When running dotnet test, there is no built-in mechanism to retry failed tests, and constructing the filter format for re-running them is non-trivial. This post showcases a new dotnet global tool dotnet-retest that fixes this. TL;DR;: Install: dotnet tool install -g dotnet-retest Run: dotnet retest Sometimes, flaky tests are just unavoidable for reasons that are outside the scope of this post. If you think those should never happen and never DO happen to you, this post is not for you :). I have tried in the past to work around this by doing fancy bash scripting for CI retries but...
        </description>
        <pubDate>Sat, 17 Aug 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/dotnet-retest.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/dotnet-retest.html</guid>
      </item>
    
      <item>
        <title>Auto-document dotnet CLI tool via dynamically generated markdown readme fragments</title>
        <description>
          
          Every time I create a new CLI tool, I face the challenge of keeping the project and package readme (for dotnet tools like dotnet-trx) up to date with the evolving tool itself. It’s annoying and repetitive (run with --help, copy-paste) and it’s not uncommon to end up with stale docs. Here’s one way to automate the whole thing so you can just focus on making your tool awesome. First, have your project emit the help to a text file, say help.md: &amp;lt;Target Name=&quot;RenderHelp&quot; AfterTargets=&quot;Build&quot; Condition=&quot;$(DesignTimeBuild) != &apos;true&apos;&quot; &amp;gt; &amp;lt;WriteLinesToFile Lines=&quot;```shell&quot; Overwrite=&quot;true&quot; File=&quot;help.md&quot; /&amp;gt; &amp;lt;Exec Command=&quot;dotnet run --no-build -- --help &amp;amp;gt;&amp;amp;gt;...
        </description>
        <pubDate>Tue, 16 Jul 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/auto-doc-cli.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/auto-doc-cli.html</guid>
      </item>
    
      <item>
        <title>GitHub GraphQL API Full Screen</title>
        <description>
          
          The GitHub GraphQL explorer is an awesome way to explore the GitHub API. It’s a great way to learn about GraphQL too, as you can see the schema, the types, and the queries you can make. Perhaps it’s not well-known, but it’s basically powered by an iframe that embeds the graphiql tool, which is pretty much the standard way to explore GraphQL APIs nowadays. I find the way GitHub configured it to be claustrophobically small, though. And no matter how wide your monitor is, it stays put with the same tiny width. It’s almost unusable. Not a big deal if...
        </description>
        <pubDate>Thu, 11 Apr 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/gh-graphql.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/gh-graphql.html</guid>
      </item>
    
      <item>
        <title>Auto-notifying cascading values in Blazor</title>
        <description>
          
          When using Blazor cascading values, especially root-level, the build-in mechanism will not notify other components of changes in the value properties. This post showcases an improved mechanism that leverages CascadingValueSource and INotifyPropertyChanged to automatically notify all components. As reported to the team the problem is that the CascadingValueSource doesn’t itself invoke its NotifyChangedAsync method so that components consuming the cascading value can refresh their rendering. This is a problem when you change properties of the shared object across components that are otherwise not in the same hierarchy (parent-child where the cascading value is provided by the parent). So far, the...
        </description>
        <pubDate>Sat, 20 Jan 2024 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/cascading-blazor.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/cascading-blazor.html</guid>
      </item>
    
      <item>
        <title>SponsorLink: feedback and moving forward</title>
        <description>
          
          As I mentioned in my introduction post on SponsorLink, open source sustainability is a tricky topic. I have been doing open source for more than 20 years, so I’m not entirely n00b to the space. I don’t believe in “experts” anyway, so I’m just going off of my personal experience, things I read and saw other fellow developers do in the past and so on. So, if it wasn’t clear enough, I’m not speaking for anyone but myself. I don’t represent the “dotnet OSS community”, or speak as to “how OSS should be/is done” or what is “right” or “wrong”...
        </description>
        <pubDate>Tue, 15 Aug 2023 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/sponsorlink-feedback.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/sponsorlink-feedback.html</guid>
      </item>
    
      <item>
        <title>How to create SDK-style VSIX project</title>
        <description>
          
          Pretty much everyone on the .NET ecosystem moved to the so-called SDK-style projects. Amazingly, even today (as of now, VS 2022 17.7 Preview 2.0) the out of the box template for VSIX projects still uses the legacy (and awfully verbose) format. So, forget the built-in VSIX template and just create a plain class library, and tweak it as follows: &amp;lt;Project Sdk=&quot;Microsoft.NET.Sdk&quot;&amp;gt; &amp;lt;PropertyGroup&amp;gt; &amp;lt;TargetFramework&amp;gt;net472&amp;lt;/TargetFramework&amp;gt; &amp;lt;!-- If you don&apos;t have a VS Package --&amp;gt; &amp;lt;GeneratePkgDefFile&amp;gt;false&amp;lt;/GeneratePkgDefFile&amp;gt; &amp;lt;!-- Import build tools --&amp;gt; &amp;lt;CustomAfterMicrosoftCSharpTargets Condition=&quot;$(VsSDKInstall) != &apos;&apos;&quot;&amp;gt;$(VsSDKInstall)\Microsoft.VsSDK.targets&amp;lt;/CustomAfterMicrosoftCSharpTargets&amp;gt; &amp;lt;/PropertyGroup&amp;gt; &amp;lt;PropertyGroup&amp;gt; &amp;lt;!-- Enables F5 --&amp;gt; &amp;lt;StartAction&amp;gt;Program&amp;lt;/StartAction&amp;gt; &amp;lt;StartProgram&amp;gt;$(DevEnvDir)devenv.exe&amp;lt;/StartProgram&amp;gt; &amp;lt;StartArguments&amp;gt;/rootSuffix Exp /log&amp;lt;/StartArguments&amp;gt; &amp;lt;/PropertyGroup&amp;gt; &amp;lt;ItemGroup&amp;gt; &amp;lt;!-- Minimal references that should...
        </description>
        <pubDate>Thu, 29 Jun 2023 00:00:00 +0000</pubDate>
        <link>https://www.cazzulino.com/sdk-style-vsix.html</link>
        <guid isPermaLink="true">https://www.cazzulino.com/sdk-style-vsix.html</guid>
      </item>
    
  </channel>
</rss>
