http://webodf.org/ https://github.com/kogmbh/WebODF https://adityabhatt.wordpress.com/2013/12/16/bringing-opendo...

A js library that renders OpenDocument Format docs in the browser, and lets you edit them collaboratively in realtime - with lovingly, meticulously crafted OT.

We worked on this with 2 years of active development - it is HARD to build a full richtext editing engine from scratch! - but it has recently been suffering from a lack of enough funding to keep the work going. I no longer get paid to work on this, so now there is only one person working on it full-time.

It deserves funding and support. As far as I know there isn't any other project that comes this close to building a full blown FOSS Google Docs text editor replacement.

:)

Thanks for the kind words! :)

This might actually replace a whole category of intranet wikis.

Adds a management command that generates views, forms, urls, admin, and templates based off the contents of models.py.

It's a bit like Rails scaffolding, but less magical. For each view it creates, for example, it will include stubbed out versions of almost all the methods and attributes you can override, in the order that they get called. The most "magical" part are the admin files that get generated, as they make use of a mixin I wrote that makes (hopefully) intelligent choices for list_display, list_filter, search_fields and automatically links to the related objects for each ForeignKey/OneToOneField. All the default choices are easily overridable.

https://github.com/krisfields/django-baker

It's not a big project but it's my first open source contribution so I'm proud of it nonetheless.

Vim Licenses (vim plugin): https://github.com/antoyo/vim-licenses Vim Plugin that provides commands to add licenses at the top of the buffer (very useful when working on open-source projects).

It's a one-way syncer utility in Node, and backed by a CLI. I Was tired of Ruby file watchers running rsync and waiting the seconds it took for file synchronization. So I wrote this which uses WebSockets to persist a connection and send deltas much quicker. Ideal for small, iterative changes (front-end).

Is it secure? No. Does it work for everything? Probably not. But it get's me waaay more productive than I was.

http://github.com/ehmatthes/intro_programming

It got some stars when I first introduced it about a year ago, but I'm mentioning it because I've just picked up development on the project again. It's a site to help people teach and learn Python. I wanted to make an easy way for experienced Python devs to contribute to a site that helps people learn Python.

Key features:

- If you can use IPython Notebook, you can contribute to the project. Every page is an IPython Notebook that gets converted to html. To edit a page, check out the project and edit the notebook.

- If you want to add a tutorial - for example, a tutorial about how to use PyGame, or how to use a specific data visualization tool, or any specific Python library - just make a new notebook, write your tutorial using IPython Notebook, and run intro_programming/scripts/build_html_pages.sh.

I just pushed a branch that updates the infrastructure to IPython 3.0. I'm a day or two away from updating the first project on the site, which shows how to plot recent earthquakes on a world map - that project has been well received for the last year. (http://introtopython.org/visualization_earthquakes.html)

If you're interested in helping out, get in touch or open an issue.

They're CC licenced and you can create your own print templates:

http://www.interfacesketch.com/

> https://github.com/ericclemmons/react-resolver

When React came out, I was disappointed that server-side rendering was pretty much impossible unless you knew _all_ of the data requirements for the entire render tree & loaded them up front.

This project has just underwent a rewrite for React v0.13 that I'm pretty proud of, since it's ES6 and packaged as ES5 via Babel.

It's been fantastic in my personal & work projects, and has made it possible to rebuild a major application that was in PHP entirely in Node w/ progressive enhancement.

https://github.com/epantry/django-sql-explorer

Engineers or analysts write SQL queries, and share them with anyone in the business who needs the data to make decisions. Through over a year of heavy, daily real-world use, I've added dozens of little usability features that make it (for me at least) really pleasant to use. It's still a pretty under-the-radar Django app, but I literally can't imagine life without at, at any business I've ever worked at.

Explorer can also expose select queries as read-only pages to specific users and we use this feature to keep investors and partners up to date on key metrics and financials which saves a lot of time and ad-hoc reporting. Just go to a URL and BAM! Real time data, downloadable as CSV.

I've also documented the version and license of every dependency to make it as easy as possible for businesses to go ahead and use it. And finally, it's extensively tested via automation, and our own internal deployment which is always running off the tip of master. We dogfood every commit quite heavily.

I'm going to try it out with my next Django project.

Github: https://github.com/semitrivial/poral

Hawkeye - https://github.com/ipartola/hawkeye. This is a webcam streaming server for the Raspberry Pi + cheap webcams. I wanted a simple, extensible webcam monitoring system for the nursery, so I built this. You can use a cheap USB webcam that supports MJPEG video, and Hawkeye has a built-in HTTP/HTTPS server for streaming the video to desktop or mobile browsers. The included "client" is just a basic HTML page that lets you view multiple streams. The project is written in what I consider fairly readable C. The whole thing can be easily built into a Debian package so maintenance is pretty simple, and init scripts just work.

groper - https://github.com/ipartola/groper. groper is a configuration library that Python's stdlib is really missing. Python comes with argparse for command line arguments, and the config parser module for parsing config files. It is your job to make the two work together. groper takes all that pain away from you. You simply define what stuff is configurable and what names it should use, and it will take care of order of precedence, etc. Works with Python 2 & 3, and will even generate sample configs for you based on your defaults. A former employer of mine uses it extensively, and so do a few other projects.

LogHog - https://github.com/activefrequency/loghogd. My current employer, Active Frequency, LLC (https://www.activefrequency.com/) sponsored my work on this. LogHog is a logging facility similar to syslog, but not compatible with it. Instead it supports a few advanced features (encryption, HMAC, built-in file rotation and compression) and basically Just Works. If you have ever tried to set up syslog logging with Python and got frustrated, give this a go. Active Frequency uses this for some of our projects, and it works really well for the most part (except that TLS, which works but configuration still has some sharp corners).

https://github.com/google/gumbo-parser

It's one of the most conformant (if not the most conformant - 0.10.0 passes all html5lib-trunk tests) standalone HTML parsing libraries out there. It has third-party bindings in nearly a dozen different languages. The API is simple, the code is robust and well-tested, and being written in C, it's often a fair bit faster than alternatives.

http://www.netsurf-browser.org/projects/hubbub/

https://echoplex.us/ - anonymous chat, code, draw, WebRTC calls, with PGP support. Much less maintained nowadays

Main site at http://intercoolerjs.org

I'm particularly proud of how well history-aware AJAX is working out: you just add an ic-push-url="true" attribute to your element, and, blam, AJAX is integrated with your apps history. See:

http://intercoolerjs.org/examples/history.html

* ND4J - Scientific computing for the JVM https://github.com/deeplearning4j/nd4j

* Vectorization lib for Machine Learning Tools https://github.com/deeplearning4j/Canova

https://github.com/endeav0r/rdis - Visual reverse-engineering tool for Linux with custom graph layout stuff.

You may think about doing a version with https://github.com/kristopolous/BOOTSTRA.386 ...

Chances are I won't be updating it anytime soon though, because I have so many other projects, so feel free to fork it and/or drop a pr, which i'll get around to merging eventually.

I'm personally kind of proud of another project (https://github.com/kennethrapp/embedbug) which I meant originally to be a self-hosted replacement for site profile services like embed.ly, but which has kind of grown into a general purpose xpath based web crawler. I've been using it in various toy forum and news aggregator projects and it seems to work pretty well, although of course it's only one of countless crawlers out there.

https://acoustid.org/ https://bitbucket.org/acoustid

There has been a few attempts at open source audio fingerprinting service before and after AcoustID, but none of them survived for long. It's been 5 years since I started working on this. I'm particularly proud of the project, because I have done it the way I think software should be done and it worked wonderfully. I spend a lot of time researching, then ran some experiments, set myself some goals of what is practical to do and what exact use cases I want to support, designed and implemented it and then I was able to run it without any scaling problems for years.

I've been the lead for Web2project for the years since we forked from dotproject. In the simplest terms, we're a project management system but unlike something like Basecamp, we handle dependencies, logging time on tasks, accounting for projects costs and a ton of other things.

At present, we have a small community, but we have a few thousand installs ranging tiny two-person shops who have a ton of things going to at least one US Air Force Base.

The biggest challenge since our fork was dealing with the old code and continuing to support older versions without leaving people without a path forward. I put a ton of time into making sure the upgrade/update process works smoothly and no data is lost.

A project that finally got some appreciation after a couple of years is [python-ftfy], which Fixes Text For You. It repairs mojibake, and generally takes in bad Unicode and outputs good Unicode.

[langcodes]: https://github.com/LuminosoInsight/langcodes

[python-ftfy]: https://github.com/LuminosoInsight/python-ftfy

https://github.com/duplicati/duplicati

http://www.duplicati.com/

Duplicati is a backup client (with GUI) that securely stores encrypted, incremental, compressed backups on cloud storage services and remote file servers. It works with Amazon S3, Windows Live SkyDrive, Google Drive, Rackspace Cloud Files or WebDAV, SSH, FTP (and many more). Built-in AES-256 encryption and backups can be signed using GNU Privacy Guard.

PS: This should be a monthly thread like "who's hiring"!

Other than GUI and Windows (VSS) support, I couldn't easily find how Duplicati diffentiated itself... might be nice to have a "Duplicati vs Duplicity" page?

The one I'm most proud of is probably MumbleSharp (https://github.com/martindevans/MumbleSharp) which is a complete implementation of the mumble protocol in C#. It's actually getting fairly close to complete, it can handle all functions except sending voice.

There are some missing features and bugs still but it's working pretty well.

* Path rewriting (grafting) -- this lets you mount an LVM snapshot somewhere, and the backed up copy can be stored referencing the original path (i.e., if you backup a snapshot of /srv/mydbfiles mounted on /mnt/snapshots/mydbfiles, you can tell it to store it on the backup server as if it was backed up from /srv/mydbfiles). This also works the other way for restoring files.

* Safe expiring of old backups -- Let say you haven't backed up a particular host for a number of months (i.e., it has been decommissioned). When you tell the system to expire all backup older than 6 months, it will by default keep the 3 most recent backups [this number is tunable on the command line].

* Multiple user / granular permission support [ in the development branch, should make it in the next release ] -- You can give a given user ID the ability to backup but not restore, or backup and restore but not purge old backups, etc. That way if a host is compromised, you can ensure that an attacker can't delete backups from that compromised host.

* If used in client/server mode, you can back up a client from the server without installing anything other than an SSH key (it just calls GNU find/tar on the client).

Things missing that are currently being coded up:

* Client side encryption

* Multiple backend support (to support tape or cloud replication)

* Local shadow copy -- lets you back up a laptop to a network server, but also do incremental snapshots to a local USB device when not on the network, and sync that to the network copy periodically.

winpcap(http://www.winpcap.org/)

A lot of people probably use this Emacs package without knowing it, since several "starter kit" Emacs config templates use it by default. It aims to completely replace emacs completion with ido[1] completion.

[1] http://emacswiki.org/emacs/InteractivelyDoThings

- Graft [https://github.com/graftjs/graft]. Our attempt to determine what microservices taken all the way to the browser would look like. It's a higher level library built on top of jschan. The idea is to be able to use node streams interchangeably on both sides of the pipe, with the communication managed by libchan ... and work invisibly over SPDY or websockets or whatever.

Unfortunately, SPDY was replaced by http2, which meant that libchan went under construction for a bit while the library support was figured out. At the same time, io.js happened. And now there's a very fastly evolving streams spec that is feeding on the whatwg effort to standardise a stream spec for the browser and node.

I am going to take up the mantle again, but there needs to be some settling of the ecosystem first. =\

Testing system for Javascript, explicit and example-based, with nice support for async testing, and I think it treats test failures particularly nicely. I think it's a way better model than BDD. But no one has ever really cared about doctest.js, even to complain...

was on this for a while. learned alot from the awesome team.

https://github.com/rip747/cfml-liquid - CFML Port of the Liquid Templating language

always wanted liquid available for CFML so I put my time where my mouth was and did it myself. learned a ton and had an awesome time doing it.

https://github.com/pjungwir/aggs_for_arrays - C functions to compute stats on PostgreSQL arrays.

I don't know about pride but I'm pretty happy with it.

http://robots-everywhere.com/re_wiki/index.php?n=Main.Softwa... Released early 2010, full Android robotics stack.

(It is "open source", but I want people to email me for the source because... well, it's interesting to chat).

Dust is flexible asynchronous templating for both the browser and server.

The project languished for awhile, which I think led to it falling by the wayside popularity-wise. I picked up development last year, and the last nine months or so have seen rapid improvement of the language and documentation.

I feel like Dust would fit many use cases way better than people's current templating solutions. Because it's asynchronous, you can put Promises and Streams right into your template variables, and Dust will handle them properly.

So for example, you can pass ReQL cursors straight into Dust, and it'll stream them into the template, so you get progressive rendering in the browser without buffering the whole result set in memory.

    r.table("messages").orderBy({index: "date"}).run(conn, function(err, cursor) {
      dust.render("inbox", { messages: cursor }).pipe(res);
    });

https://github.com/argonium/jarman

- https://github.com/zserge/anvil - a new reactive UI library for android. It totally changed the way I develop android apps now.

Also there is some tiny ones, but found useful over the years:

- https://bitbucket.org/zserge/jsmn/wiki/Home - JSMN, a very fast and lightweight JSON parser for embedded systems

- https://bitbucket.org/zserge/mucks - A wrapper for Tmux/Screen/DVTM to keep persistent terminal sessions. Usefule when you use terminal as an IDE

- https://bitbucket.org/zserge/gambiarra - minimalist Lua unit-testing library

Mostly operational framework for implementing lightweight federation with OpenStack and Bitcoin. Worked on it for a year before starting to work again as a technology evangelist. Still noodling on it when I have time.

The world's best open source content management system https://github.com/SpontaneousCMS/spontaneous

http://jeffail.github.io/leaps/

The above link has a three step guide for pair programming your local files over LAN (including installation). The service is quite flexible and also allows you to share hosted documents through MySQL and postgreSQL and do things like user authentication etc.

I have a pair programming website set up as a proof of concept that uses leaps with postgreSQL here: https://megrim.uk/, it's hosted across three ARM micro computers under my sofa so go easy on it.

Javascript event system - https://github.com/kristopolous/EvDa

* Self-contained

* Piecemeal

* Vertically sophisticated - simple things remain simple; hard things remain possible

* Focus on pleasant, consistent, ease, and flexibility

My end-users are programmers and my UX is the API and documentation.

I care about facilitating both novice and experienced programmers equal enjoyment and proportional productivity with the most minimum ramp-up necessary.

If I have to think about how to do it in the library or look up how to invoke things, I consider that an impetus for re-design.

Community-Driven Standards For Popular Types Of Data in JSON.

Think Products, Blog Posts, Events, Contacts, etc.

http://robots-everywhere.com/portfolio/navcom_ai/

Longshoreman is a simple solution for deploying Docker containers to a server cluster.

Norm is a lightweight layer over JDBC. Access a database in one line of code.

We get a few hundred downloads of each release, but I like to think that the market for people who want to program their desktop, has to be a bit bigger than that :)

(Our website sucks, which probably doesn't help, but we don't currently have any contributors who are good at making pretty web sites)

Is a free/libre guide teaching how to find out what your users’ needs are.

http://www.mbtest.org/ https://github.com/bbyars/mountebank

There are some excellent HTTP/S stubbing libraries out there but no open source ones that let you also stub other protocols. mountebank was first built to support testing Java serialization over a mule-based TCP layer, supports HTTP/S, SMTP, and I'm working on first-class SOAP support. The only tools that provide this capability today are commercial (e.g. CA Lisa) and not nearly as friendly to CI/CD practices.

By the way, thanks for this thread. Independently of my own self-promotion, it's a great idea. Great open source developers are rarely good marketers, which means the best tools often rot in obscurity, and users of the tools rarely recognize that they can help by the simplest of actions. Find the ones you like on this page, star them, fork them, link to them. Help the open source community shine.

It's a "universal package format". It's similar to lazyfs (from 0install) with a bit more structure for packages. It's digitally signed from end-to-end. It uses FUSE. It supports writing, SUID files, and advanced configuration which can be updated at runtime without unmounting.

https://github.com/droope/droopescan

I've been working on it for heaps! Sponsored in part by the company I work for, I reckon it's pretty decent ^^

API testing with Cucumber: https://github.com/hidroh/cucumber-api

Easy to use, kind of quick linear programming / mixed integer linear programming solver in javaScript that takes models as easy to understand javaScript objects instead of tableaus.

https://github.com/chrislusf/seaweedfs

Seaweed-FS is a simple and highly scalable distributed file system. There are two objectives: to store billions of files! to serve the files fast!

As far as I can tell, the only free software capable of doing this.

It's entirely dumb and not very useful.

This is what the "Show HN:" submission convention is for.

For most trivial algebra, it's quicker to use paper and pencil than a full algebra system. Ket is a faster alternative with the benefit of clipboards, save/load and export to LaTeX and HTML.

Most algebra consists of recombining existing expressions. These can be added in plain text and substituted into one another by clicking and dragging one equation into another. You can then reorganize the resulting equation using click-and-drag algebra by dragging terms to different parts of the equation, e.g. y=mx+c y-c=mx (y-c)/m=x x=(y-c)/m.

Most real-world algebra problems require translation from real-world information into a coherent mathematical framework. For simple cases, the standard approach is the back-of-the-envelope calculation. This shows only enough working to keep the idea organized in your mind as you solve it. This part of a maths problem is more akin to writing the first draft of an essay. That is, you list relevant known equations and solution fragments which you organize into a coherent narrative.

For this you need an algebra-centred text editor. Most of the time spend doing algebra on computers or on paper is writing and rewriting respectively. To avoid this, Ket is a modal editor (built around Vim-like commands) in which keyboard letters correspond to simple editing commands. That is, the editor focuses on transforming existing expressions and only incidentally on adding new ones. In addition to redrafting working, with each command, the user performs an algebraic step.

A text editor represents a line of text as a list of characters. Ket represents an equation as a tree of functions, constants and variables. And instead of a cursor editing around a particular character, editing takes place around a tree branch. So editing commands edit a function, variable or value at a time in plain text while keeping the larger whole in conventional mathematical notation. And because each command is a single key press, each editing step is as quick as touch typing. Furthermore, while some commands perform algebraic transformations, others simply edit the data structure. This is analogous to algebra on paper where symbols are cancelled by scoring them out.

A text editor represents an essay as a list of lines of characters. Ket represents a document as a list of equations where each is represented as a tree of functions, constants and variables. Instead of a cursor editing around a particular character, editing takes place around a tree branch. So editing commands edit a function, variable or value at a time in plain text while keeping the larger whole in conventional mathematical notation. And because each command is a single key press, each editing step is as quick as touch typing. Furthermore, while some commands perform algebraic transformations, others simply edit the data structure.