A free Windows-compatible Operating System

ReactOS Project

Current version: 0.4.6 

Quick Links

• Website
• Wiki
• Forum
• JIRA Bug Tracker
• ReactOS Git mirror
• Testman

What is ReactOS?

ReactOS™ is an Open Source effort to develop a quality operating system that is compatible with applications and drivers written for the Microsoft® Windows™ NT family of operating systems (NT4, 2000, XP, 2003, Vista, Seven).

The ReactOS project, although currently focused on Windows Server 2003 compatibility, is always keeping an eye toward compatibility with Windows Vista and future Windows NT releases.

The code of ReactOS is licensed under GNU GPL 2.0+.

Building

To build the system it is strongly advised to use the ReactOS Build Environment (RosBE). Up-to-date versions for Windows and for Unix/GNU-Linux are available from our download page at: http://www.reactos.org/wiki/Build_Environment

Alternatively one can use Microsoft Visual C++ (MSVC) version 2010+. Building with MSVC is covered here: https://www.reactos.org/wiki/Building_with_MSVC

Binaries

To build ReactOS you must use run configure script in the directory you want to have builds. Choose configure.cmd or configure.sh depending on your system. Then run ninja <modulename> to build a module you want or just ninja to build all modules.

Bootable images

To build a bootable CD image run ninja bootcd from the build directory. This will create a CD image with a filename bootcd.iso.

See "Building ReactOS" for more details.

Installing

ReactOS can only be installed on a machine that has a FAT16 or FAT32 partition as the active (bootable) partition. The partition on which ReactOS is to be installed (which may or may not be the bootable partition) must also be formatted as FAT16 or FAT32. ReactOS Setup can format the partitions if needed.

To install ReactOS from the bootable CD distribution, extract the archive contents. Then burn the CD image, boot from it, and follow instructions.

See "Installing ReactOS" Wiki page or INSTALL for more details.

Testing

If you discover a bug in ReactOS search on JIRA first - it might be reported already. If not report the bug providing logs and as many information as possible.

See "File Bugs" for a guide.

NOTE: The bug tracker is not for discussions. Please use #reactos Freenode IRC channel or our forum.

More information

ReactOS is a Free and Open Source operating system based on the Windows architecture, providing support for existing applications and drivers, and an alternative to the current dominant consumer operating system.

It is not another wrapper built on Linux, like WINE. It does not attempt or plan to compete with WINE; in fact, the user-mode part of ReactOS is almost entirely WINE-based and our two teams have cooperated closely in the past.

ReactOS is also not "yet another OS". It does not attempt to be a third player like any other alternative OS out there. People are not meant to uninstall Linux and use ReactOS instead; ReactOS is a replacement for Windows users who want a Windows replacement that behaves just like Windows.

More information is available at: https://www.reactos.org.

Also see the media\doc subdirectory for some sparse notes.

Who is responsible

Active devs are listed as members of GitHub organization. Also see the CREDITS file for others.

Code mirrors

The main development is done on GitHub. We have an alternative mirror in case GitHub is down.

There is also an obsolete SVN archive repository that is kept for historical purposes.

Bring deep learning to bare metal

NNVM compiler offers reusable computation graph optimization and compilation for deep learning systems. It is backed by the TVM stack and provides modules to:

• Represent deep learning workloads from front-end frameworks via a graph IR.
• Optimize computation graphs to improve performance.
• Compile into executable modules and deploy to different hardware backends with minimum dependency.

NNVM is designed to add new frontend, operators and graph optimizations in a decentralized fashion without changing the core interface. The compiled module can be deployed to server, mobile, embedded devices and browsers with minimum dependency, in languages including c++, python, javascript, java, objective-c. Checkout our release announcement

The following code snippet demonstrates the general workflow of nnvm compiler.

import tvm
from tvm.contrib import graph_runtime, rpc
import nnvm.frontend
import nnvm.compiler

# GET model from frameworks
# change xyz to supported framework name.
graph, params = nnvm.frontend.from_xyz(...)

# OPTIMIZE and COMPILE the graph to get a deployable module
# target can be "opencl", "llvm", "metal" or any target supported by tvm
target = "cuda"
graph, lib, params = nnvm.compiler.build(graph, target, {"data", data_shape}, params=params)

# DEPLOY and run on gpu(0)
module = graph_runtime.create(graph, lib, tvm.gpu(0))
module.set_input(**params)
module.run(data=data_array)
output = tvm.nd.empty(out_shape, ctx=tvm.gpu(0))
module.get_output(0, output)

# DEPLOY to REMOTE mobile/rasp/browser with minimum tvm rpc runtime
# useful for quick experiments on mobile devices
remote = rpc.connect(remote_host, remote_port)
lib.export_library("mylib.so")
remote.upload("mylib.so")
rlib = rpc.load_module("mylib.so")
# run on remote device
rmodule = graph_runtime.create(graph, rlib, remote.gpu(0))
rmodule.set_input(**params)
rmodule.run()

nnvm

nEXT - The fastest productivity web-browser

nEXT Browser

nEXT is the fastest productivity browser. It is designed from the ground up to be customizable for your workflow. nEXT Browser is the infinitely EXTensible browser.

Powerful Features

Fast tab switching

Switch easily between your open tabs by fuzzy search. If you are looking for http://www.example.com, you could type in ele, exa, epl, and any other valid series of letters. In a future release, typing any semantically related word will give you a fuzzy search of your open tabs and let you quickly find which page you were looking for.

History as a tree

History is represented as a tree that you can traverse. More complex than the “forwards-backwards” abstraction found in other browsers, the tree makes sure you never lose track of where you’ve been.

In the example below, the User performs the following actions:

1. Starts page Athens
2. Visits page Ancient Greek
3. Returns to page Athens
4. Visits page Classical Athens
5. Returns to page Athens
6. Executes forwards keybind in history

It is at this point that a normal browser would NOT be able to navigate you forwards to your visit of Ancient Greek. Instead of erasing your history, nEXT offers smart navigation and prompts the user. Do you wish to go forwards to Ancient Greek or to Classical Athens?

Getting Started

Install nEXT Browser

See the releases section for pre-built binary releases.

Quickstart Keys nEXT

• C-l: Load URL in Buffer
• S-l: Load URL in a new buffer
• C-c C-X: Quit

Customize nEXT

Customization is possible through the creation of a ~/.next.d/init.lisp file within your home directory. From here you can override and redefine any of the functions by defining your init file as part of the :next package.

Documentation

For full documentation about nEXT, how it works, and how to extend it please see the documents/MANUAL.org file.

nEXT

Fetish-themed programming language

Fetlang

Fetlang is a statically typed, procedural, esoteric programming language and reference implementation. It is designed such that source code looks like poorly written fetish erotica

Fetlang is not recommended for production use at this moment, especially in medical or military applications

Example

The following example outputs the arguments given to the executable:

Make Sean moan
Worship Carrie's feet

Bind Amy to Saint Andrew's Cross
    Have Amy hogtie Sean
    If Amy is Carrie's bitch
        Make Slave scream Sean's name
        Make Sean moan

Features

• Input/output with standard streams and files
• Statically typed
• Gendered variables
• Access previously mentioned variables using pronouns
• Numbers represented internally as fractions instead of floating point
• Transpiles to C
• Case insensitive
• Confusing English-like syntax and unhelpful error messages
• Probably Turing complete
• Extensible - just install your fetish in share/fetlang/fetishes

Building

Requirements:

• meson
• ninja
• gcc/g++(>=4.9) or clang(>=3.5)

Optional dependencies:

• boost algorithm(>=1.62)
• boost filesystem(>=1.62)
• boost system(>=1.62)

Supported systems:

• macOS (tested with Travis CI)
• GNU/Linux (tested with Travis CI)
• Other modern Unix-like systems

Build Fetlang:

$ git clone https://github.com/Property404/fetlang
$ cd fetlang
$ meson --buildtype=release src build
$ cd build
$ # Build Fetlang
$ ninja
$ # Run unit tests
$ ninja test

Install Fetlang:

$ sudo ninja install
$ # Make sure it worked
$ fetlang ../examples/hello.fet && ./a.out
Hello World!

Documentation

Comments
Control Flow
Fetishes
Fetish Reference
Grammar
Tutorial
Types
Variables

fetlang

lottie-android

Render After Effects animations natively on Android and iOS

Oxford Deep NLP 2017 course

Preamble

This repository contains the lecture slides and course description for the Deep Natural Language Processing course offered in Hilary Term 2017 at the University of Oxford.

This is an advanced course on natural language processing. Automatically processing natural language inputs and producing language outputs is a key component of Artificial General Intelligence. The ambiguities and noise inherent in human communication render traditional symbolic AI techniques ineffective for representing and analysing language data. Recently statistical techniques based on neural networks have achieved a number of remarkable successes in natural language processing leading to a great deal of commercial and academic interest in the field

This is an applied course focussing on recent advances in analysing and generating speech and text using recurrent neural networks. We introduce the mathematical definitions of the relevant machine learning models and derive their associated optimisation algorithms. The course covers a range of applications of neural networks in NLP including analysing latent dimensions in text, transcribing speech to text, translating between languages, and answering questions. These topics are organised into three high level themes forming a progression from understanding the use of neural networks for sequential language modelling, to understanding their use as conditional language models for transduction tasks, and finally to approaches employing these techniques in combination with other mechanisms for advanced applications. Throughout the course the practical implementation of such models on CPU and GPU hardware is also discussed.

This course is organised by Phil Blunsom and delivered in partnership with the DeepMind Natural Language Research Group.

Lecturers

• Phil Blunsom (Oxford University and DeepMind)
• Chris Dyer (Carnegie Mellon University and DeepMind)
• Edward Grefenstette (DeepMind)
• Karl Moritz Hermann (DeepMind)
• Andrew Senior (DeepMind)
• Wang Ling (DeepMind)
• Jeremy Appleyard (NVIDIA)

Timetable

Practicals

• Group 1 - Monday, 9:00-11:00 (Weeks 2-8), 60.05 Thom Building
• Group 2 - Friday, 16:00-18:00 (Weeks 2-8), Room 379

Lectures

Public Lectures are held in Lecture Theatre 1 of the Maths Institute, on Tuesdays and Thursdays, 16:00-18:00 (Hilary Term Weeks 1,3-8).

Lecture Materials

1. Lecture 1a - Introduction [Phil Blunsom]

This lecture introduces the course and motivates why it is interesting to study language processing using Deep Learning techniques.

[slides] [video]

2. Lecture 1b - Deep Neural Networks Are Our Friends [Wang Ling]

This lecture revises basic machine learning concepts that students should know before embarking on this course.

[slides] [video]

3. Lecture 2a- Word Level Semantics [Ed Grefenstette]

Words are the core meaning bearing units in language. Representing and learning the meanings of words is a fundamental task in NLP and in this lecture the concept of a word embedding is introduced as a practical and scalable solution.

[slides] [video]

4. Lecture 2b - Overview of the Practicals [Chris Dyer]

This lecture motivates the practical segment of the course.

[slides] [video]

5. Lecture 3 - Language Modelling and RNNs Part 1 [Phil Blunsom]

Language modelling is important task of great practical use in many NLP applications. This lecture introduces language modelling, including traditional n-gram based approaches and more contemporary neural approaches. In particular the popular Recurrent Neural Network (RNN) language model is introduced and its basic training and evaluation algorithms described.

[slides] [video]

Reading

Textbook

• Deep Learning, Chapter 10.

Blogs

• The Unreasonable Effectiveness of Recurrent Neural Networks, Andrej Karpathy.
• The unreasonable effectiveness of Character-level Language Models, Yoav Goldberg.
• Explaining and illustrating orthogonal initialization for recurrent neural networks, Stephen Merity.

6. Lecture 4 - Language Modelling and RNNs Part 2 [Phil Blunsom]

This lecture continues on from the previous one and considers some of the issues involved in producing an effective implementation of an RNN language model. The vanishing and exploding gradient problem is described and architectural solutions, such as Long Short Term Memory (LSTM), are introduced.

[slides] [video]

Reading

Textbook

• Deep Learning, Chapter 10.

Vanishing gradients, LSTMs etc.

• On the difficulty of training recurrent neural networks. Pascanu et al., ICML 2013.
• Long Short-Term Memory. Hochreiter and Schmidhuber, Neural Computation 1997.
• Learning Phrase Representations using RNN EncoderDecoder for Statistical Machine Translation. Cho et al, EMNLP 2014.
• Blog: Understanding LSTM Networks, Christopher Olah.

Dealing with large vocabularies

• A scalable hierarchical distributed language model. Mnih and Hinton, NIPS 2009.
• A fast and simple algorithm for training neural probabilistic language models. Mnih and Teh, ICML 2012.
• On Using Very Large Target Vocabulary for Neural Machine Translation. Jean et al., ACL 2015.
• Exploring the Limits of Language Modeling. Jozefowicz et al., arXiv 2016.
• Efficient softmax approximation for GPUs. Grave et al., arXiv 2016.
• Notes on Noise Contrastive Estimation and Negative Sampling. Dyer, arXiv 2014.
• Pragmatic Neural Language Modelling in Machine Translation. Baltescu and Blunsom, NAACL 2015

Regularisation and dropout

• A Theoretically Grounded Application of Dropout in Recurrent Neural Networks. Gal and Ghahramani, NIPS 2016.
• Blog: Uncertainty in Deep Learning, Yarin Gal.

Other stuff

• Recurrent Highway Networks. Zilly et al., arXiv 2016.
• Capacity and Trainability in Recurrent Neural Networks. Collins et al., arXiv 2016.
• Optimizing Performance of Recurrent Neural Networks on GPUs. Appleyard et al., arXiv 2016.

7. Lecture 5 - Text Classification [Karl Moritz Hermann]

This lecture discusses text classification, beginning with basic classifiers, such as Naive Bayes, and progressing through to RNNs and Convolution Networks.

[slides] [video]

Reading

• Recurrent Convolutional Neural Networks for Text Classification. Lai et al. AAAI 2015.
• A Convolutional Neural Network for Modelling Sentences, Kalchbrenner et al. ACL 2014.
• Semantic compositionality through recursive matrix-vector, Socher et al. EMNLP 2012.
• Blog: Understanding Convolution Neural Networks For NLP, Denny Britz.
• Thesis: Distributional Representations for Compositional Semantics, Hermann (2014).

8. Lecture 6 - (Coming Soon) Deep NLP on Nvidia GPUs [Jeremy Appleyard]

[slides] [video]

Piazza

We will be using Piazza to facilitate class discussion during the course. Rather than emailing questions directly, I encourage you to post your questions on Piazza to be answered by your fellow students, instructors, and lecturers. However do please do note that all the lecturers for this course are volunteering their time and may not always be available to give a reponse.

Find our class page at: https://piazza.com/ox.ac.uk/winter2017/dnlpht2017/home

Assessment

The primary assessment for this course will be a take-home assignment issued at the end of the term. This assignment will ask questions drawing on the concepts and models discussed in the course, as well as from selected research publications. The nature of the questions will include analysing mathematical descriptions of models and proposing extensions, improvements, or evaluations to such models. The assignment may also ask students to read specific research publications and discuss their proposed algorithms in the context of the course. In answering questions students will be expected to both present coherent written arguments and use appropriate mathematical formulae, and possibly pseudo-code, to illustrate answers.

The practical component of the course will be assessed in the usual way.

vue

A progressive, incrementally-adoptable JavaScript framework for building UI on the web. http://vuejs.org

Intro

Vue.js is a library for building interactive web interfaces. It provides data-reactive components with a simple and flexible API. Core features include:

• Declarative rendering with a plain JavaScript object based reactivity system.
• Component-oriented development style with tooling support
• Lean and extensible core
• Flexible transition effect system
• Fast without the need for complex optimization

Note that Vue.js only supports ES5-compliant browsers (IE8 and below are not supported). To check out live examples and docs, visit vuejs.org.

https://github.com/vuejs/vue