The Kegbot Blog

The “Makr Shakr” cocktail robot at Google IO....

Wed, 15 May 2013 20:24:21 -0700

The “Makr Shakr” cocktail robot at Google IO. Slightly more involved than a Kegbot build.

One or more of these bad boys will be included with every Kegbot...

Wed, 08 May 2013 09:26:53 -0700

One or more of these bad boys will be included with every Kegbot Store order.. until we run out!

Kegbot now has a Tumblr

Tue, 07 May 2013 14:42:20 -0700

After years of steady, guilty neglect, we’ve finally ditched our home-brewed blog software and hitched our wagon to something decent.

Our new home is blog.kegbot.org, powered by Tumblr. You can look forward to more updates, more hacks and howtos, and of course, more gifs.

Goodies Ahead

We’ve got some exciting goodies to announce soon — so give that Follow button a good hearty smack and stay tuned!

Kegbot Meetup #2: San Francisco, July 16 2012

Tue, 10 Jul 2012 23:39:00 -0700

That’s right, it’s time for another Kegbot Meetup! This time, our pals over at Eventbrite have graciously offered to lend us some space to hang out, talk shop, and maybe even reveal a few new Kegbot goodies.

The Details

Where: Eventbrite HQ, 651 Brannan Street, Suite 110, San Francisco
When: Monday, July 16, 7pm-9pm
What: Fun, adventure, and beer!

If you’re building a new Kegbot system, yours truly will be on hand to help answer questions and get you set up. We’ll also have Kegboards and some related parts on hand to help troubleshoot.

Be There

Now, we’re not promising drinks or refreshments or prizes beyond human comprehension.. but you should probably RSVP if you’re coming.

Preview: Kegbot and Android

Tue, 30 Aug 2011 23:35:00 -0700

You’d have to be living under a rolling rock — or maybe just not following Kegbot on Twitter — to have missed our latest mad invention: Kegbot for Android!

Android, Arduino, and Beer

Chief among the goals of Kegbot for Android is to making building and running a Kegbot dead simple, and to bring a cool new touchscreen UI to your tap. But really, we just wanted to combine three of our favorite pastimes: Android, Arduino, and of course, beer!

Coming Soon

We’re currently testing this in a very small private beta, but we’ll have more goodies and a release soon. Reload this page continuously until then!

You Asked, We Delivered: Kegbot Moves to Github

Sun, 12 Jun 2011 23:35:02 -0700

Put down those knives and pick up your forks: starting with the just-released Kegbot version 0.8.0, we’ve moved Kegbot to Github! Google Code has been good to us, but the people have spoken.

It is no secret that Github has become the de facto social hub for opensource projects, and, we’ll, we’re curious to see if we’ll receive more contributions from you intrepid hackers this way. Plus, like we said a few years ago, you gotta switch version control systems every year or two to stay cool.

Start following us on Github, and send us your pull requests! http://github.com/kegbot

Kegbot Version 0.8.0 Released

Sun, 12 Jun 2011 23:33:31 -0700

After a 6 month release hiatus, we squinted at the tip of the Kegbot tree, liked what we saw, and decided to slap a version number on it: Kegbot v0.8.0 is out!

New Features & Stuff

You can check out the changelog for all of the exciting details; highlights:

Relay support has returned to the Kegbot core and the Kegboard firmware. Impress your friends and defy your enemies by locking them out!
Under the hood, the Kegbot core program now uses the Kegbot REST API to report drinks. Sip your pours with the satisfaction of knowing a MYSQL connection to your backend was not required to log it!
Many small tweaks to the Kegweb interfaces. (We’re doing what we can, but our HTML/CSS “skills” are about as weak as a half pint of O’Douls. Help welcome.)

Head on over to the downloads site and grab a copy for yourself.

Kegbot Meetup, San Francisco: This Tuesday, April 5th!

Wed, 30 Mar 2011 23:32:30 -0700

Holy hoppin’ hell, has it really been over 6 months since our last blog post? We’ve been hard at work behind the scenes, with a lot of goodies in store for Kegbot this spring. But we need to start by making amends the only way we know how: with a ritualistic public flogging at a local watering hole.

You’re invited!

Join us this Tuesday, April 5th, 7pm at Nihon Whiskey Lounge for the first ever Kegbot Meetup.

What’s going to go down? It’s anyone’s guess! Some of the hottest internet rumors may include:

Raffles and giveaways of prizes from local merchants;
An expert panel on the roles of gender and sexuality in keg management;
A special appearance by a famous rap celebrity;

… or maybe it’ll just be some nerds hanging out, talking about ways to make their beer refrigerators irrationally complicated. Who knows.

What’s that you say? A whiskey lounge for a beer meetup? Yes, we’re going to be as out of place as a shirtless saxaphone player at a ROSS Dress-for-Less. Which is to say, it’s going to be awesome.

The fun will start at 7pm. For safety reasons, commit access to the kegbot repository will be temporarily suspended shortly thereafter. Don’t wait — book your cross-country flights today!

Welcome the the new Kegbot Blog

Thu, 23 Sep 2010 23:31:07 -0700

You’ve made it! Welcome to the new Kegbot Blog.

A brave new world

We migrated the old blog away from blogspot.com and into the kegbot.org tent. Truly this is exciting day in Kegbot history (if not world history).

Tastes about as good, same filling

Chief among the many benefits you will enjoy from this seemingly uninteresting infrastructure change are:

Part of the kegbot.org site — no more hunting for bookmarks and hand-scrawled post-it notes when you want the latest Kegbot news.
Commenting integrated with your kegbot.org account. (Don’t tell us you don’t have one yet? I seem to have.. something in my eye.. I’m not crying, I swear.. Just set one up.)
Shorter URL. Because unlike life, on the internet, shorter is better.

A call to action

If you’ve not already done so, please update your bookmarks (and the bookmarks of at least two friends). Here are the essentials:

Blog: http://kegbot.org/
RSS feed: http://feeds.feedburner.com/kegbot

Last call, round 2: Kegbot Arduino shield PCB

Thu, 12 Aug 2010 02:03:00 -0700

Thanks to some recent prodding and help from Geoff over at Kegbot Milwaukee, we’re getting very close to building a batch of “Kegshield” boards for our Kegboard firmware. I know, we said “last call” in our last post — what, you’ve never heard of a lock-in?

Though we originally proposed a 2-tap Arduino shield, we had an epiphany after a morning shave with a 5-bladed razor and said, “Fuck everything, we’re doing six taps.” With some swagger in our step, we proudly announced that the shield has been redone, in luscious Arduino Mega proportions.

But building a board flexible and cheap enough for lots of different configurations has required hard decisions to be made. In addition to dropping the perplexing (and irritating) on-board strobe light, and the prohibitively complex “douche sensor”, we’ve once again settled on a smaller, pint-sized layout. Here’s a recent draft:

We’re still retaining the features that seem most important and commonly useful, including:

4 general-purpose relays, for valves (or springing elaborate traps)
2 RJ45 “keg tap” jacks, each with connections for two flow meters and OneWire temperature/authentication sensing
Stackable, can put other Arduino goodies on top
Optional XBee interface, wirelessly reprogrammable

We’re still tweaking with the layout, but mostly there. What does it mean? Hop on #kegbot if you’d like to get some last-minute bling on this thing!

Last call: Kegbot Kegboard Shield, Second Draft

Sun, 02 May 2010 04:30:00 -0700

Update, Aug 2010: See our most recent post with even more changes.

After chatting with a few Kegbotters about the first draft Kegboard arduino shield (thanks for the feedback, Geoff, Jared, and others!), we realized our last design was like making an afternoon visit to Toronado, only to settle for a half-pint of Pliny the Elder: the glass isn’t half-full, it’s just too damn small!

So, on a sunny San Francisco Saturday, we drew the blinds, tapped into our reserve cache of SmartPower energy drink, and spent the next 8 hours fiddling around madly in our favorite board editor. The Kegboard shield has been reworked around an Arduino Mega footprint; here’s the result:

And, the corresponding, much girthier schematic:

The new design has all of the features of the first draft, plus:

Up to six RJ45s, one for each supported flowmeter input. (Each jack routes two flow inputs, as shown in the annotated board, so you can support 6 taps with 3 cables.)
4 relay blocks, for switching small loads on and off.
6 general purpose blocks (power, ground, and signal), for use with an external device (such as the SparkFun relay board.)

Of course, those without the luxury of an Arduino Mega (or 6 taps - jeez, guys!) can depopulate many of the components here and use it in 2-tap mode with a plain old Arduino. The relay blocks, general output blocks, and most of the RJ-45s are all optional, bringing the component cost down to a 6-pack or two.

Your author still has a few tweaks to make (the optional XBee device needs some level shifting, and some components might be rearranged), but overall we’re very close to sending this one off to BatchPCB for a test fab.

Last call: Problems? Ideas?

What would you like on your Kegboard Arduino Shield?

Wed, 21 Apr 2010 15:59:00 -0700

Our Kegboard firmware has been pretty solid these days, and we’ve been pretty happy with the features afforded by the basic Arduino Duemilanove board. So, the time has come to stamp out an Arduino “shield” daughtercard, making it as simple as AOL 9.0 to get your Kegbot online.

The First Draft

Shown above is the first draft of the schematic.

And the corresponding board layout (your author has not yet performed the board routing). Note that the shield intentionally hangs to the right and bottom of the carrier Arduino, to provide adequate clearance from the components below.

Current Features
Here are the board’s current features, as of today anyway (this is all subject to change).

Two RJ45 ‘keg ports’. Each RJ45 breaks out both flow meter inputs, the temperature sensor OneWire bus, and power and ground connections. Using a Cat-5 cable or two, all sorts of combinations should be possible: monitor two taps in one fridge with a single cable, or one tap and a dollar bill acceptor with both ports, or two separate fridges, and so on.
LEDs at each keg port, which can be used to signal tap activity.
One RJ11 ‘authentication’ connection. This is wired to the OneWire presence-detect bus, and the pinout matches the famous blue dot receptacle.
Onboard buzzer; right now, the kegboard firmware doesn’t do too much with it (it chimes on powerup), but we could easily do a software update to add alarms.
Socket for optional XBee transciever; read the kegboard remotely.
Pins for optional board level temperature sensor; conveniently add ambient room temperature monitoring to your Kegbot setup by soldering in an extra DS18B20.
Two 3-pin screw terminal headers, each with power, ground, and an LED-signalled general purpose output. Use this to interface with a relay board, external alarm trigger, or whatever.

What to add?

We’ll probably spend a few more days tweaking the schematic and layout. Unless any great ideas pop up, the first batch will likely look something like this. (We’re not sure if we’ll sell boards, kits, or anything at all ourselves — but we’ll at least make it easy for you to order the parts and boards online.) Leave a comment if you have suggestions.

Appendix A: Kegboard v1.0

Back in 2005, in the bad old days before we knew about Arduino, SparkFun, and plentiful Eagle libraries, we put together the original Kegboard: Kegboard v1.0. Here’s what it looked like:

(Image unscrupulously stolen from Make’s coverage of a rare public appearance by the reclusive team Kegbot.)

The board itself featured a PIC16 micocontroller, a socket for an (expensive) FTDI USB-serial converter, and two relays. Compared to our current design, you could say it was a complete solution, though not with its problems (and higher cost). We might return to a 100% integrated board one day, after Kegbot takes over the world, but for now we’re happy to build off of the Arduino.

"Tips" for your Kegerator: Kegbot, meet Dollar Bill Acceptor

Mon, 19 Apr 2010 22:23:00 -0700

Finally, this blasted device is starting to earn its keep!

After 13 kegs and an untold number of free drinks, your author hooked his dollar bill acceptor up to the Kegbot, just in time for Superbowl Sunday. With a custom cardboard chassis & intimidating signange, this Kegbot extension warns, “Hey! No more free rides, suckers, because I’m ready to guilt trip you into slinging a few bucks into the tip jar!”

History

We first wrote about dollar bill acceptors back in November 2004 (!), a time so distant it was back when your author referred to himself in the first person (and with little regard for capitalization.) Soon after filing our last report on the topic, we place the acceptor in a storage closet and forget about it for years.

It turns out that our Arduino tap controller hardware/software, Kegboard, is perfectly suited to the task of interfacing with the bill acceptor. Like the flow meters we use, the bill acceptor has an open-collector output that sends out a pulse train, one pulse for every dollar collected.

Since we weren’t using the second tap/interrupt input (your author sadly only has one tap on his keg), we re-purposed it for listening to the bill acceptor. One devious hack to the kegbot core later and we have simple support for recording dollar contributions. If a user is authenticated while the bills are flowing in, we record that, too.

Construction

Obviously the most striking feature here is our lovingly hand-crafted designer cardboard chassis. Here are some construction notes.

Here’s the MAG50B, making a triumphant return to the Kegbot blog. The enclosure is a little weird, since it is designed to sit in a vending machine; the front face hangs an inch or two beneath the bill-stacker box, so it can’t easily stand upright on its own.

With a crowd on its way over for beer, this intrepid (and in all likelihood at the time, slightly drunk) hacker used the best materials available to him: this is to say, not very good ones. (Mechanical design prowess has never been our expertise.)

The sturdy plastic front face of the acceptor is removable, for bolting to your favorite cola machine or shoebox.

Using the face as a guide, we cut a small template in the bottom of the shoebox. It isn’t shown, but in theory this orientation makes it possible to open the ‘top’ of the shoebox to remove bills from the bill stacker unit.

And here’s the hole after being cut.

Next was the matter of power and pulse signal output. We will sheepishly omit providing details about the cruel solder job that became necessary due to a lack of parts (and time) — but you should be able to fashion a nice connector using the details from our previous post.

A look at the logic board. I’ve surely voided my warranty, oh well.

The finished setup: success! Don’t forget to use a pull-up resistor on the pulse output.

Total dollars collected: About $10, not including author’s test dollars. Hey, it’s a start..

Future Work

Clearly, the most important feature remains to be implemented: those with unpaid (or overdue) balances should be locked out of the Kegbot (or at least ridiculed via the LCD). Long-time kegbotters will remember this as an original feature, but one your author ripped out long ago for a rewrite.

We have grand plans for a “version 2.0” of the drinker accounting system, including user or group-targeted drink pricing, and account statements. We will soon reintroduce better support for solenoid-valve access control, too, so tell all your cheap friends that their freeloading days are numbered.

Code corner: Recent Kegbot changes

Wed, 09 Dec 2009 23:00:00 -0800

It has been a quiet month or two since we relaunched the kegbot.org site, so we don’t have too many cool new features to write about. But we thought some readers might enjoy — or at least, might not be board to tears by — a round up of some recent changes to the kegbot code.

More Taps, More Fun!
On October 13th, we checked in a change to our Kegboard Arduino firmware project that allows it to monitor up to 6 flow meters (instead of 2), when using an Atmega 1280. This MCU has a ridiculous number of IO pins, and so it was trivial for us to add support for the four extra external interrupt lines. If you compile Kegboard for an Atemga 1280 board, such as the Arduino Mega, you’ll have automatic support for 6-tap glory.

(And if you need help “testing” all of those taps, feel free to drop us a line… Santa Cruz Kegbot, I’m look at you…)

Kegbot Master: The Master of your Daemons
As you may know from our meager-but-slowly-improving-documentation, a working Kegbot linux system is actually comprised of a few programs which must run together. Starting and stopping all of these daemons was getting a bin tedious, so we checked in a simple application to manage that: kegbot_master. We still need to update our Getting Started guide, but you can get a head start by peeking at it now.

Faster Kegboard Main Loop
Ok, so we’re really hurting for new things to point out, but if you haven’t updated your Kegboard firmware in a while, now might be a good time: a sorta-recent change removes an artificial update delay that has long been part of the Kegboard firmware. Previously, it could take up to 250ms for a Kegboard to report a flow or iButton event to the serial port. With this delay removed, the rest of the Kegbot system that depends on the Kegboard — the LCD feedback, authentication system, and other components — should be that much snappier.

Epilogue
We’re still experimenting here, so we hope you enjoy this light, inaugural edition of the “code corner”. We’ve got some more interesting changes to make soon, so we’ll try to make the next edition even more existing. It won’t take much..

Relaunch of kegbot.org site

Sun, 25 Oct 2009 17:23:00 -0700

This will be a quick one, partly because the topic does not lend itself easily to bad jokes, and partly because we’ve already tweeted about it (isn’t that enough?)

The Kegbot.org site has been relaunched; we’ve now got ourselves a message board for interested kegbotters, and some new goodies will be coming soon!

How to RFID enable your Kegerator

Mon, 05 Oct 2009 13:02:00 -0700

Okay, so we may have lied in our last post. Although iButtons have long been our preferred way to authenticate to Kegbot, we’ve actually come up with something that is even more fun to use. Now presenting: the RFID-controlled Kegbot!

The reader itself costs about $50, and it is probably possible to get one cheaper. I use self-adhesive EM4102 (125 KHz) RFID tags, which cost about a buck each — less expensive than a DS1920 iButton and FOB by a few dollars. Initial support for the RFID reader as an authentication device has been checked in to kegbot.

HOWTO build your own RFID pint glass reader

You will need the following basic components:

A USB RFID reader; I use the Phidget reader.
A plastic drip tray. A steel tray might work, but may require some modification.
A disposable food storage container.

Here’s a pictoral overview.

Above: plastic drip tray, Phidgets USB RFID reader, disposable plastic food storage container.

Pop open the drip tray.

To get a feel for where the reader will go, you can place it inside. We’ll mount it upside-down (so that the USB socket doesn’t get in the way), around the center of the tray (right where the glassware would be placed).

Now, it is time to build a protective beer raincoat for our little “RFID reader that could”. Here’s where the food storage container comes in. Eat last night’s leftovers, wash out the container, and discard the lid.

We’re going to slice off most of the container, so that we’re left with about 1/2” tall hood.

Using the plastic drip tray as an approximate guide, slice off the top of the container. I found that scissors actually work better, once you have a starter slice:

You will be left with something that looks like this:

Next, you are going to want to test your surgical prowess by trying to fit the grille portion of the drip tray back into place, with the hood sitting in the tray.

If your tray is like mine, you’ll need to hack off a plastic standoff to make room for the hood:

When properly assembled, the grille should fit atop the hood like so:

Next, you will need to create something to prop the reader up off the bottom of the drip tray, so that it is a safe distances away from drip tray muck (and as close as possible to the top of the drip tray). At this point, some screw-in plastic standoffs would be great, but I did not have any handy.

I attempted to build standoffs out of leftover Ikea bookshelf dowels and small nails; this was a total failure. Instead, I managed to build a support out of something much more plentiful: party cup!

As you can see, no plastic foodware was spared the wrath of my “de-topping” rampage on this afternoon.

Next, I duct taped the little party-cup riser to the RFID reader, flipped the whole assembly over, and placed it in the top. I cut out a notch for the USB cable.

Finally, I found USB cable that I was comfortable dooming to a slow, sticky decline, and placed the entire assembly in the drip tray. (I opted to simply thread the cable out of the tray’s top rather than drilling something in the side, since I didn’t want to compromise the tray’s ordinary liquid capacity.

Here’s a close-up of the finished assembly:

And another, once assembled back together:

Finally, I stuck a little RFID sticker on the bottom of my mug and poured a drink:

Touchless beer authentication saves the day! Or.. something.

Conclusions & Future Ideas

Overall, this is a lot of fun; it compliments the iButton reader (both happily coexist at the same time), and it definitely adds a “magic” factor to the kegbot, especially when the LCD greets you by name after swinging your glass into position.

The longevities of the adhesive on the RFID, and of the ID itself, still remain to be seen. The tags I’ve used seem pretty sturdy, and I’ve put my mug through a couple of hot washes and the tag still works, but I wouldn’t be surprised if it falls off one day.

If you have a mug you use regularly, adding an RFID tag to it could be lots of fun. Though the tags are probably less robust (and more likely to fall off or get lost) compared to an iButton, their price is low enough that I could see them still being useful in party situations: buy a bunch of tags for $1 each, charge people up front for cups for at least that much, and expect the tag and cup to be thrown away at the end of the night.

Taking the party concept one step further, the Kegbot core could even grow to support a ‘gift card’ type mode, where a particular authentication token is credited for a certain amount of beer, and no specific user account.

Finally, there are plenty of other tag types (including sturdier keychain fob packages), so there’s no requirement that the RFID be in the pint glass, or even the drip tray.

I’m sure we will think of plenty of other fun things to do with this. Time to order some more tags!

Kegboard hops aboard the 1-wire bus

Sun, 27 Sep 2009 06:13:00 -0700

Longtime Kegbot followers will know that we have something of a penchant for 1-wire iButton devices. They’ve been part of the Kegbot since drink 1 (ok, drink 100), and are our preferred drinker identification method.

Sure, Kegbot can support other means of authentication, but nothing we’ve found matches that satisfying “clunk” of pressing an iButton into its socket — and being rewarded with beer.

Until recently, we’ve recommended using the DS9404R USB-to-1-Wire adapter. While this little gizmo is a pretty painless way to add 1-wire support to Linux box, it comes at a price: about $25 and one spare USB port, to be exact.

Worse, while the device is supported in the Linux kernel, one of its primary features is crippled: hardware offload of the bus search function simply does not work. (Your author can confirm this firsthand, having made several fruitless attempts to get this feature to work as advertised in his own implementation.) For Kegbot, bus search is essential: we use the 1-wire device IDs as a unique “secret token” identifier for each user.

Thankfully, these days are now behind us: we recently added support for detecting and reporting 1-wire device IDs in the Kegboard beer keg controller board; farewell, DS9490! (Sharp-eyed observers may note that we’ve actually supported 1-wire temperature sensors in the Kegboard for a while, so we’re not exactly doing anything that earth-shatteringly new.)

Check out the updated Kegboard Guide for more information on how to use this new feature.

Tip o’ the hat to Jared on kegbot-dev for inspiring us to complete this feature.

Jumping the shark, or getting cool: Kegbot tweets!

Thu, 10 Sep 2009 22:33:00 -0700

Well, it’s official: Either we’ve jumped the shark, or we have created the hippest dang kegerator on the planet: Kegbot now tweets. (solemn silence). We can safely say that not since Beenz has there been a more important and groundbreaking advance in internet technology!

Although Kegbot has been recording drinks and causing trouble for over 5 years, until recently there was no convenient way to immediately notify your friends (and stalkers) about your drinking habits. These days are over.

We tip our hat (and raise our glass) to a couple of projects that have helped pave the way to our own special brand of irritating microbrew microbanter:

@TweetingBar is the first tweeting keg that we know of, but what we’re really impressed by is his sharp tongue.
Wired’s @beerrobot sports a paint job that makes our black Haier feel quite beige, and it just got a flowmeter upgrade.
Those wacky guys who dig up and sell all sorts of cool components, SparkFun, just got @SparkFunKeg online. They’re also using a very interesting sensor.

You might ask: How is @kegbot anything new, or different from its tweeting brethren? Well, unlike some tweeting kegs, Kegbot is able to personalize its tweet… to the person pouring! (shocked gasps)

And now, for some boring technical details…

The Twitter support was added as an optional drink post-processor in the Kegbot core. During a normal Kegbot pour, users authenticate to the Kegbot to get credit for their drink (via iButton, password, whatever).

After the drink is completed and recorded, an event is passed to the Twitter post-processor, which begins to generate the tweet. The volume of the drink, the permanent drink URL, and the keg name are extracted from the new drink’s record.

The volume is compared to a configurable rank of drink sizes (small/average/large), and a smug response is randomly selected. It is the kegbot admin’s responsibility to populate the database of smug responses, ranging from petulant and taunting (small drink), to mildly enthusiastic (average drink), to genuinely impressed (large drink) — at least, as close to those emotions as a bot can get, which (based on your author’s attempts) is not very close..

Finally, the post-processor looks up the drinker’s Kegbot profile and determines if the twitter name is known. If it is, the tweet is personalized with the drinker’s name (eg @mik3y); if not, the Kegbot username is used. The tweet is posted as the configured Twitter account for that Kegbot system.

Now that the basics are in place, there are several more “fun” things we might consider, including:

Tweet as the drinker, so your friends (who are not interested in following your beer bot) can be advised of your habits (“Warning, I’m on my 5th drink; ignore subsequent tweets.”)
Tweet keg change events, temperature status, and go into cat-in-heat mode when there has been little activity (“I’m lonely!”)
Dump in some temperature sensor readings; Attach pictures from the pours in flight; etc.

You get the idea: it is Twitter, after all; anything and everything must be made to use it… somehow. Here at Kegbot, we’re happy to oblige.

Code news: Mercurial switch

Thu, 10 Sep 2009 21:55:00 -0700

You know the drill. Version control systems are like Linux distributions: every few years, there’s a new kid on the block — and he wants your revision history.

Here are the new links, which you can also get to from our handy Kegbot Google Code Project link over there on the right:

Browse source: http://code.google.com/p/kegbot/source/browse/
Checkout source: http://code.google.com/p/kegbot/source/checkout

We switched to Mercurial because it is a distributed version control system. We hope this will make it a tiny bit easier for you to contribute patches and extend Kegbot.

Kegbot lives... again!

Thu, 10 Sep 2009 21:50:00 -0700

Well, hello there!

It’s been a quiet few years over here at Kegbot HQ — almost 3, to be exact! We hope you didn’t miss us. A lot has changed in the world since out last post. To recap the years 2006-2009 for those of you who have also been hibernating:

Twitter
Obama
Michael Jackson

What do these have to do with Kegbot? Nothing! But we have been up to some cool things behind the scenes that actually do matter, which we will cover in the next series of posts, including:

A new home for our opensource project;
A new and improved Kegboard — that you can actually build in a weekend!;
Brand new documentation — that you can actually read in a weekend!;
New extensions to the Kegbot core.

Stay tuned.