Introducing Alive

tl;dr: We built this:


Write code. Compile. Run.

To most of us, this is what programming “is”. But when we really stop to think about it, this is a pretty bizarre way to create. We’ve divided up programming into these separate worlds of “design-time” and “debug-time”.

At design-time we make our changes, we imagine what the computer will do and start the program up. At “debug-time” we test our theories and see if we were right.

It’s like painting with a blindfold on. Once blindfolded, we make our marks and do our best to imagine how we’d like our painting to look. Occasionally we remove the blindfold see how badly we’ve done. Then we get to put it back on and try to correct our mistakes.

This seemed backwards to us. We wanted a frictionless design loop. One where we gain an instant connection to the programs we create.

So we built a tool to do this.

What is it?

Alive is a live programming environment for Visual Studio that currently supports C#. It blurs the line between “design-time” and “run-time”. As you write your code, you’re shown exactly what the code will do at runtime. It responds instantly as you update variables and manipulate code.

In a sense, Alive lets you travel through time. You can rewind and fast forward through loops. You can jump up and down the callstack of a recursive method call. This is fantastic for quickly tracking down bugs and edge cases.

See Alive in action:

What can it do?

Alive really shines when you’ve written unit tests and can run any code touched by one of your tests. You simply select the test you’d like to run against your method and watch as the values pop into existence. This is a lifesaver when trying to understand or modify code written by someone else.

Alive can also run any static method if you’re willing to provide parameters for it. This is useful when exploring and playing around with small programs. Essentially Alive can act as a replacement for a REPL and allow you to iterate and experiment quickly.

What can it not do?

It’s important to note that areas that Alive was not built to support. Alive isn’t very good at working with long running code. If you’re backtesting stock data, Alive probably isn’t the tool you’re looking for. This is because occasionally we’re re-running your code. We’re bound to the speed of your code and can’t show you the results until your code is finished running. (We’re working on providing partial results to you as you type. Unfortunately, this functionality won’t make it into the June alpha).

Alive should be used with caution when running code with real world side effects. If you’re constantly adding items to your database while using Alive you should expect to see a few extras items in there. We’re not running your code on every keystroke, but we are running it a handful of times as you type.

Alive is not great for running against non-deterministic code. If your unit tests periodically don’t run certain pieces of code, it can be difficult for us to know which unit tests correspond to which methods. You can work around this issue by selecting the unit tests you know will hit a given method.

What’s next?

Our next major milestone will be the alpha release on June 1. We’re currently testing Alive against various unit test frameworks including XUnit, NUnit and MSTest. We’re still working to solve some bugs and improve performance on large projects.

To save 30% on a licesnse, you can pre-order at The license will be valid for one year after the release of v1.0. You may use Alive after the license expires, but you will no longer receive updates and bugfixes for Alive.

For updates on Alive subscribe to our newsletter at

8 thoughts on “Introducing Alive

  1. Impressive; I wonder what the “commenting is evil” crowd will think of this? I know it’s not exactly the same thing…maybe not at all the same, but everything new is hated by at least a subset of people.

    1. I think the “comments are evil” crowd dislikes comments because they’re often misleading and not checked by the compiler. (It’s easy to edit a piece of code and forget to update the comment). Alive always shows you exactly what your code is doing so hopefully this is acceptable to them.

    2. I can’t figure out why you think this has anything to do with comments or the “commenting is evil” crowd. Personally, I don’t think comments are necessarily “evil”, but perhaps “guilty until proven innocent”.

      On the other hand, I really like what I’m seeing demonstrated here. It reminds me of the debugger experience in Elm (, which is a positive association.

  2. Very impressive and excellent work! Keep it up and you’ll find yourself assimilated into VS directly in not too long. 🙂

  3. Great idea! I am curious how Alive will show the “value” of complex types. Since C# is primarily an object oriented language, most of my variables are classes/complex types and not primitive types.

    ToString()? Hover the “value” results in a full list of properties? (Or a combination of the two options?).

    1. Our approach has just been to show the .ToString() of the current object. This may sound limiting at first, but remember you can simply type var x = complexObject.PropertyImInterestedIn; and it will display almost immediately.

      In a sense, you can now treat your source code as an Immediate Window.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s