It's been three months since we open sourced React and it is going well. Some stats so far:

• 114 285 unique visitors on this website
• 1933 stars and 210 forks
• 226 posts on Google Group
• 76 Github projects using React
• 30 contributors
• 15 blog posts
• 2 early adopters: Khan Academy and Propeller

Wolfenstein Rendering Engine Ported to React #

Pete Hunt ported the render code of the web version of Wolfenstein 3D to React. Check out the demo and render.js file for the implementation.

React & Meteor #

Ben Newman made a 13-lines wrapper to use React and Meteor together. Meteor handles the real-time data synchronization between client and server. React provides the declarative way to write the interface and only updates the parts of the UI that changed.

This repository defines a Meteor package that automatically integrates the React rendering framework on both the client and the server, to complement or replace the default Handlebars templating system.

The React core is officially agnostic about how you fetch and update your data, so it is far from obvious which approach is the best. This package provides one answer to that question (use Meteor!), and I hope you will find it a compelling combination.

var MyComponent = React.createClass({
 mixins: [MeteorMixin],

 getMeteorState: function() {
   return { foo: Session.get('foo') };
 },

 render: function() {
   return <div>{this.state.foo}</div>;
 }
});

Dependencies will be registered for any data accesses performed by getMeteorState so that the component can be automatically re-rendered whenever the data changes.

Read more ...

React Page #

Jordan Walke implemented a complete React project creator called react-page. It supports both server-side and client-side rendering, source transform and packaging JSX files using CommonJS modules, and instant reload.

Easy Application Development with React JavaScript

Why Server Rendering?

• Faster initial page speed:
  • Markup displayed before downloading large JavaScript.
  • Markup can be generated more quickly on a fast server than low power client devices.
• Faster Development and Prototyping:
  • Instantly refresh your app without waiting for any watch scripts or bundlers.
• Easy deployment of static content pages/blogs: just archive using recursive wget.
• SEO benefits of indexability and perf.

How Does Server Rendering Work?

• react-page computes page markup on the server, sends it to the client so the user can see it quickly.
• The corresponding JavaScript is then packaged and sent.
• The browser runs that JavaScript, so that all of the event handlers, interactions and update code will run seamlessly on top of the server generated markup.
• From the developer's (and the user's) perspective, it's just as if the rendering occurred on the client, only faster.

Try it out ...

Today we're happy to announce the initial release of PyReact, which makes it easier to use React and JSX in your Python applications. It's designed to provide an API to transform your JSX files into JavaScript, as well as provide access to the latest React source files.

Usage #

Transform your JSX files via the provided jsx module:

from react import jsx

# For multiple paths, use the JSXTransformer class.
transformer = jsx.JSXTransformer()
for jsx_path, js_path in my_paths:
    transformer.transform(jsx_path, js_path)

# For a single file, you can use a shortcut method.
jsx.transform('path/to/input/file.jsx', 'path/to/output/file.js')

For full paths to React files, use the source module:

from react import source

# path_for raises IOError if the file doesn't exist.
react_js = source.path_for('react.min.js')

Django #

PyReact includes a JSX compiler for django-pipeline. Add it to your project's pipeline settings like this:

PIPELINE_COMPILERS = (
  'react.utils.pipeline.JSXCompiler',
)

Installation #

PyReact is hosted on PyPI, and can be installed with pip:

$ pip install PyReact

Alternatively, add it into your requirements file:

PyReact==0.1.1

Dependencies: PyReact uses PyExecJS to execute the bundled React code, which requires that a JS runtime environment is installed on your machine. We don't explicitly set a dependency on a runtime environment; Mac OS X comes bundled with one. If you're on a different platform, we recommend PyV8.

For the initial release, we've only tested on Python 2.7. Look out for support for Python 3 in the future, and if you see anything that can be improved, we welcome your contributions!

This is the first Community Round-up where none of the items are from Facebook/Instagram employees. It's great to see the adoption of React growing.

React Game Tutorial #

Caleb Cassel wrote a step-by-step tutorial about making a small game. It covers JSX, State and Events, Embedded Components and Integration with Backbone.

Reactify #

Andrey Popp created a Browserify helper to compile JSX files.

Browserify v2 transform for text/jsx. Basic usage is:

% browserify -t reactify main.jsx

reactify transform activates for files with either .jsx extension or /** @jsx React.DOM */ pragma as a first line for any .js file.

Check it out on Github...

React Integration with Este #

Daniel Steigerwald is now using React within Este, which is a development stack for web apps in CoffeeScript that are statically typed using the Closure Library.

este.demos.react.todoApp = este.react.create (`/** @lends {React.ReactComponent.prototype} */`)
  render: ->
    @div [
      este.demos.react.todoList 'items': @state['items']
      if @state['items'].length
        @p "#{@state['items'].length} items."
      @form 'onSubmit': @onFormSubmit, [
        @input
          'onChange': @onChange
          'value': @state['text']
          'autoFocus': true
          'ref': 'textInput'
        @button "Add ##{@state['items'].length + 1}"
      ]
    ]

Check it out on Github...

React Stylus Boilerplate #

Zaim Bakar shared his boilerplate to get started with Stylus CSS processor.

This is my boilerplate React project using Grunt as the build tool, and Stylus as my CSS preprocessor.

• Very minimal HTML boilerplate
• Uses Stylus, with nib included
• Uses two build targets:
  • grunt build to compile JSX and Stylus into a development build
  • grunt dist to minify and optimize the development build for production

Check it out on Github...

WebFUI #

Conrad Barski, author of the popular book Land of Lisp, wants to use React for his ClojureScript library called WebFUI.

I'm the author of "Land of Lisp" and I love your framework. I built a somewhat similar framework a year ago WebFUI aimed at ClojureScript. My framework also uses global event delegates, a global "render" function, DOM reconciliation, etc just like react.js. (Of course these ideas all have been floating around the ether for ages, always great to see more people building on them.)

Your implementation is more robust, and so I think the next point release of webfui will simply delegate all the "hard work" to react.js and will only focus on the areas where it adds value (enabling purely functional UI programming in clojurescript, and some other stuff related to streamlining event handling)

Read the full post...

Today we're releasing a gem to make it easier to use React and JSX in Ruby on Rails applications: react-rails.

This gem has 2 primary purposes:

1. To package react.js in a way that's easy to use and easy to update.
2. To allow you to write JSX without an external build step to transform that into JS.

Packaging react.js #

To make react.js available for use client-side, simply add react to your manifest, and declare the variant you'd like to use in your environment. When you use :production, the minified and optimized react.min.js will be used instead of the development version. For example:

# config/environments/development.rb

MyApp::Application.configure do
  config.react.variant = :development
  # use :production in production.rb
end

// app/assets/javascript/application.js

//= require react

Writing JSX #

When you name your file with myfile.js.jsx, react-rails will automatically try to transform that file. For the time being, we still require that you include the docblock at the beginning of the file. For example, this file will get transformed on request.

/** @jsx React.DOM */
React.renderComponent(<MyComponent/>, document.getElementById('example'))

Asset Pipeline #

react-rails takes advantage of the asset pipeline that was introduced in Rails 3.1. A very important part of that pipeline is the assets:precompile Rake task. react-rails will ensure that your JSX files will be transformed into regular JS before all of your assets are minified and packaged.

Installation #

Installation follows the same process you're familiar with. You can install it globally with gem install react-rails, though we suggest you add the dependency to your Gemfile directly.

React v0.4.1 is a small update, mostly containing correctness fixes. Some code has been restructured internally but those changes do not impact any of our public APIs.

React #

• setState callbacks are now executed in the scope of your component.
• click events now work on Mobile Safari.
• Prevent a potential error in event handling if Object.prototype is extended.
• Don't set DOM attributes to the string "undefined" on update when previously defined.
• Improved support for <iframe> attributes.
• Added checksums to detect and correct cases where server-side rendering markup mismatches what React expects client-side.

JSXTransformer #

• Improved environment detection so it can be run in a non-browser environment.

Download it now!