CoffeeScript-dotnet

Command line tool for compiling CoffeeScript. Includes a file system watcher to automatically recompile CoffeeScripts when they change. Roughly equivalent to the coffee-script node package for linux / mac.

CoffeeSharp

Includes a command line tool similar to CoffeeScript-dotnet as well as a http handler that compiles CoffeeScripts when requested from an asp.net site.

SassAndCoffeeScript

Library for Asp.net mvc that compiles sass and coffeescript files on request. Also supports minification and combination.

Manually Compile With IronJS

IronJS is a .NET javascript interpreter that can successfully load the CoffeeScript compiler and compile CoffeeScript.

Manually Compile With Node.js

Get the node binaries and add the bin directory to your path. Write a node.js script to load the CoffeeScript compiler and your CoffeeScript files and save the compiled javascript.

CoffeeScript is now fully supported by Chirpy: http://chirpy.codeplex.com/

You specifically said that you wanted to write a runtime compiler, so this may not be exactly what you are looking for, but if the main point is to have a way to generate the javascript result, the Mindscape Web Workbench is interesting. It is a free extension for Visual Studio.NET 2010 and available in the Extension Manager. It gives Intellisense, syntax highlighting and compiles to JS as you write. I am just getting started using it but looks promising. Scott Hanselman talks about it here. It also supports LESS and Sass.

I ve managed to compile CoffeeScript from .NET using IKVM, jcoffeescript and Rhino. It was straightforward, except that the JCoffeeScriptCompiler constructor overload without parameters didn t work. It ran OK with a java.util.Collections.EMPTY_LIST as parameter.

This is how I did it:

1. Download IKVM, jcoffeescript and Rhino.
2. Run ikvmc against js.jar, creating js.dll.
3. Run ikvmc against the jcoffeescript jar.
4. Add a reference to the jcoffeescript dll in Visual Studio. More references may be needed, but you will be warned about those.
5. Run new org.jcoffeescript.JCoffeeScriptCompiler(java.util.Collections.EMPTY_LIST).compile() in your code.

The next step would be to create a build task and/or an HTTP handler.

Check out the new coffeescript-dotnet project, which uses the Jurassic JavaScript implementation.

Since the CoffeeScript compiler now runs on Internet Explorer, after a couple of recent tweaks, it should be good to go within other MS-flavors of JavaScript as well. Try including extras/coffee-script.js from the latest version, and you should be good to go with CoffeeScript.compile(code).

I tried running the bundled extras/coffee-script.js through Windows Based Script Host (or just wscript) and it didn t report any issues. I then added this line:

WScript.Echo(CoffeeScript.compile( a: 1 ));

at the end of the file and run it through wscript again and it printed the resulting JavaScript correctly.

Are you using COM objects? Can you share some more of the code responsible for initialising the MScript object reference?

CoffeeScript in Visual Studio 2010

It s Chirpy s fork (chirpy is a tool for mashing, minifing, and validating javascript, stylesheet, and dotless files)

"OK, I think I got it working on my fork, based mostly on other peoples work. Check it out: http://chirpy.codeplex.com/SourceControl/network/Forks/Domenic/CoffeeScriptFixes"

from http://chirpy.codeplex.com/workitem/48

I don t have a direct answer, (I hope you find one), but maybe take a look at the following to see how it might be done.

• Jint - JavaScript interpreter for .NET
• Using IKVM to compile Rhino would get rid of the Java runtime requirement.
• jcoffeescript. I haven t looked at jcoffeescript, but I think it depends on JRuby and Rhino. You could possibly IKVM.NET this as well.

IronJS now supports CoffeeScript and is generally faster than the other .NET JS engines:

I have a blog post about wiring the two together here:
http://otac0n.com/blog/2011/06/29/CoffeeDemo-A-Simple-Demo-Of-IronJS-Using-CoffeeScript.aspx

My main editor is VS 2010 and I love the WorkBench extension. it s nice it auto compiles to js everytime you hit save on your .coffee file, also introduces you to SASS which I had read about but never got around.

They offer a pay version to that will autmaically shrink/minify your js and css files as well, since your.coffee and .scss are your source files anyway.

I d encourage all VS users to go ahead and install this especially if you run VS 2010.

The only knock, and someone please correct me or enlighten me, is that with .coffee syntax it s not highlighted the way say html, js, c# code is. it might be because I am using a color scheme from http://studiostyl.es/ and for the record http://studiostyl.es/schemes/coffee- just shares the name coffee no special syntax highlight support for coffeescript that I am aware of. but no reason not to start using the workbench addin today!

Okay workbench website claims: syntax highlighting so again maybe it s the studiostyle.es i chose.

I know this is old but I came here to answer a very similar question: How do I get my CoffeeScript to compile using Visual Studio 2012 Express? Note that the free Express version does not allow any extensions so I could not continue to use the Mindscape Workbench extension that had served me well for quite some time.

It turns out to be very easy. Just use NuGet to install the Jurassic-Coffee package and off you go.

One advantage of using this package over mindscape workbench is that you can reference your coffee directly from the script tags in the html. It minifies and caches the compiled JS so you only do work if the requested coffee file has changed.

<head>
    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
    <script src="home.coffee"></script>
</head>

The mindscape workbench allows you to bundle together different coffescript files which is very handy for modularising your coffeescript. You can also do this using Jurassic Coffee by utilising the #= require statement to include other coffee module files, for example:

#= require ClassesGridWrapper.coffee
class UsersGrid
  constructor:->
     @grid = new GridWrapper()

I think having the #= require staement in the coffee file is actually cleaner and clearer than the mindscape workbench approach, which kind of hides all this behind their interface so you forget easily what dependencies you have.

Note There is one potential gotcha. The Nuget installer will put in an httphandler entry into your web.config that may not be compatible with IIS Express integrated managed pipeline mode.

You might therefore see the following error:

An ASP.NET setting has been detected that does not apply in Integrated managed pipeline mode.

To fix this just remove the handler shown below.

<system.web>
  //other stuff

  <httpHandlers>
    <add type="JurassicCoffee.Web.JurassicCoffeeHttpHandler,JurassicCoffee" validate="false" path="*.coffee" verb="*" />
  </httpHandlers>

</system.web>

You could simply write a port of it to C#. I have ported Jison to C# (which is the underlying project that makes CoffeeScript run). I would think it may be a bit different, but both Jison parsers work the same.

I have not pull requested it back yet to Jison s main architecture, but will be doing so soon.

https://github.com/robertleeplummerjr

Instead of shelling out to CScript you could shell out to Node.js (here are self-contained Windows binaries)

I ve tried to compile the extras/coffee-script.js file, unmodified, to jsc, the JScript.NET compiler for .NET, and I got many errors. Here are the noteworthy ones:

• require is a new reserved word and should not be used as an identifier
• ensure is a new reserved word and should not be used as an identifier
• Objects of type Global Object do not have such a member

Other errors were caused by the above said errors.

You might also want to check out jurassic-coffee, it is also a coffee-script compiler running the original compiler in jurassic.

It features sprocket style "#= require file.coffee" or "#= require file.js" wich can be used to keep .coffee files modular and combined right before compilation as well as embedding .js files.

It sports a HttpHandler with file watchers for .js and .coffee files that keeps track of what .coffee files needs to be re-compiled and pass through to the compiled *.js files for the rest.

jurassic-coffee is also available as a Nuget package

https://github.com/creamdog/JurassicCoffee

I ve done an HttpHandler that uses Windows Script Host behind the scenes: https://github.com/duncansmart/LessCoffee and works great (it also compiles *.less files).

It s on NuGet: http://nuget.org/List/Packages/LessCoffee

It s based on this simple wrapper: https://github.com/duncansmart/coffeescript-windows

I wrote an inteructive shell using v8.

https://github.com/mattn/coffee-script-v8

This work as single executable file. (Don t use external files) It can t use require(). But enough to learn coffeescript.