Processing Camera RAWs with OpenImageIO and Python

15 Sep 2014

I recently discovered the library OpenImageIO, an awesome tool for reading and writing image files. What makes this of particular interest is the sheer variety of image files supported (BMP, Cineon, JPG, JPG-2000, GIF, DPX, OpenEXR, Targa, TIFF) (as well as variety of camera raw formats) and the fact it can perform image transformations upon them very easily. Given it’s designed for use in media and VFX environments it sounds like it will be useful for the type of work I’ve previously been involved with in stop motion.

Additionally, it comes with Python bindings, so you can do all of this without having to learn C++ if, like me, it’s been 10 years since you last used it. It also means not having to resort to use of the commandline tools I’ve often used in the past for similar transformations.

Mac Installation

I’m on a mac and as such, brew is my weapon of choice for installing libraries. Unfortunately, openimageio is only available through a tap and an old version at that. I managed to compile outside of brew, but found that I couldn’t get python to read the bindings correctly. I wanted to install a 1.5 version of the library, so found the best solution was to download the formula, modify it and tap homebrew/science to get the libraries it depends on. Your local openimageio formula takes precedence over the tapped version, so it won’t get overwritten.

wget -O /usr/local/Library/Formula/openimageio.rb
brew tap homebrew/science

You can edit the formula here if required, using more recent version.

brew install openimageio

If all goes to plan, brew should install openimageio along with all dependencies. Additionally, I’ve edited my $DYLD_LIBRARY_PATH to include the path to the installation (/usr/local/Cellar/openimageio/1.5.3dev/lib).

Reading and Processing RAWs

OpenImageIO uses the ImageBuf class to handle representation and manipulation of images in memory and functions of the ImageBufAlgo class to transform them. It’s best to demonstrate through some examples.

import OpenImageIO as oiio

# Read a camera raw, crop and write out to a tiff
buf = oiio.ImageBuf("Dino_001_01_X1_0066.cr2")
cropped = oiio.ImageBuf()
oiio.ImageBufAlgo.crop(cropped, buf, oiio.ROI(1208, 4901, 814, 2385))

# Create a new larger buffer and paste the crop into it, vertically centred
extended = oiio.ImageBuf(oiio.ImageSpec (3693, 2077, 3, oiio.FLOAT))
oiio.ImageBufAlgo.paste(extended, 0, 253, 0, 0, cropped)

# Create a new buffer, resize the extended image to 1920x1080 and add some text
resized = oiio.ImageBuf(oiio.ImageSpec (1920, 1080, 3, oiio.FLOAT))
oiio.ImageBufAlgo.resize(resized, extended)
oiio.ImageBufAlgo.render_text(resized, 1300, 1030, "00066.cr2", 50, "Arial")
oiio.ImageBufAlgo.render_text(resized, 1600, 1030, "00:00:02:18", 50, "Arial")

THat ultimately takes the following lovely shot of a dino from RAW form to that with extended borders and burnt in information.

What’s great about this is that we’ve used a single library to perform this series of transformations and we’ve not had to break out to use commandline operations to do so, instead manipulating them from the comfort of python.

Chaining commands

From using various javascript libraries (jQuery, Underscore), I’ve become used to the simplicity of being able to quickly chain a whole bunch of commands together. For that reason, I wrapped a number of the OpenImageIO ImageBufAlgo methods up into a single class OiioChain so that it’s possible to perform the same set of above transformations using a somewhat more concise syntax. You can find it on github.

from oiio_chain import OiioChain

chain = OiioChain("Dino_001_01_X1_0066.cr2")

chain.crop(1208, 4901, 814, 2385)\
    .extend(3693, 2077).resize(1920, 1080)\
    .text(1300, 1030, "00066.cr2").text(1600, 1030, "00:00:02:18")\

Displaying Images with Image Viewer

OpenImageIO even comes with it’s own built in image viewer, to handle quick display of images or to incorporate viewing capabilities into your own software. You can access this from the terminal by using the executable “iv”.

I’m really enjoying experimenting with OpenImageIO and am currently experimenting putting it into a service which performs on demand storage and transformation of media which I’ll write about further at a later date. Currently, there’s no means of being able to process stills into videos, for which further tools would be required, but I’ve heard word that work is ongoing to implement libav capabilities.

There’s such a huge amount that’s possible with the library which I’ve not covered and it should definitely be at the top of your list if you’re looking at handling RAW media for your own projects.

Tagged openimageio, python, | Leave a comment

Extracting Shot Thumbnails from a video using FFMPEG

31 Jul 2014

Recently, Andy Davies asked the following question on twitter:

I found this pretty interesting, especially given I’d used various open source tools for assembling storyboards in the past. I knew it was possible to extract images at desired intervals and left it as that.

After a bit of digging last night, I discovered it’s actually possible to extract images based on changes in the video. We can use this to extract a rough approximation to individual shots.

I’ve run the following command on the Big Buck Bunny in order to extract 138 individual changes from the 10 min short. I’m using ffmpeg version 2.3 (I had tried using ffmbc 0.7, but it is unable to parse some of the options).

ffmpeg -ss 3 -i big_buck_bunny_1080p_surround.avi -vf "select=gt(scene\,0.2)" -vsync vfr -s vga -f image2 out%02d.jpg

The real gold here is the ‘-vf “select=gt(scene\,0.2)”’, which grabs scene changes based on a difference in the frame of 20% or more. There are certain discrepancies in a couple of shots, but in the main this method works well and quickly. I specify the output format (-f) and size (-s) so that I can get small thumbs rather than the 1920x1080 the short is in.

You can see how well this performs through the selections made for the first 10 changes shown below.

In order to assemble the thumbs into an individual image I’ve used the “montage” command from imagemajick.

montage *.jpg -geometry 320x180+2+2 -tile 3x4 sample.jpg

This assembles the images in the current directory in a 3x4 grid and outputs them to sample.jpg. If there are more images that will fit in a 3x4 grid, multiple output images will be created to represent the strip.

Animation is a really good exemplar for this technique, probably due to the obvious changes between each shot. However I can imagine it would fare less well with say a live action feature, where scene changes may be more gradual and/or lighting is more subtle.

Tagged imagemajick, ffmpeg, | Leave a comment

Splitting a date range in Python

01 Jul 2014

Dates are one of those annoying things that shouldn’t be, but are regularly difficult in web apps. I used the following two methods in a recent page to neatly break a date range into distinct segments as part of a analytics app I’m currently working on. Hopefully someone else will find them helpful.

import datetime, calendar

# Find the delta between two dates based on a desired number of ranges
def datedelta(startdate, enddate, no_of_ranges):
    start_epoch = calendar.timegm(startdate.timetuple())
    end_epoch = calendar.timegm(enddate.timetuple())

    date_diff = end_epoch - start_epoch

    step = date_diff / no_of_ranges

    return datetime.timedelta(seconds=step)

date_delta allows me to create the timedeltas between two dates based on a desired number of segments.

# Edit 18/07/2014 - I realised dates needed the hrs, mins an secs correctly
# adjusted to beginning / end of day
def datespan(startdate, enddate, delta=datetime.timedelta(days=1)):
    currentdate = startdate

    while currentdate + delta < enddate:
        todate = (currentdate + delta).replace(hour=23, minute=59,second=59)

        yield currentdate, todate

        currentdate += delta
        currentdate.replace(hour=0, minute=0,second=0)

I can then pass the delta into datespan above, which returns an iterable I can then use.

# Get timedeltas based on splitting the range by 10
delta = date_delta(startdate, enddate, 10)

for from_datetime, to_datetime in datespan(startdate, enddate, delta):
    print from_datetime, to_datetime

The result forms part of the following d3 chart:

Tagged coding, python, | Leave a comment

Tips for being a more Productive Freelancer

16 Jun 2014

Having heard the question raised on @workingoutshow, I thought I’d take some time to share the things that I’ve found have really helped me be productive in my work. These may not work for everyone, but hopefully some points will help for others.

Find a Good Environment

The single biggest change I’ve found which has had a major impact on my work is changing my environment. We’re lucky enough to have a small garden at our house and with the arrival of my daughter back in October, I was quick to realise that working in the open plan lounge in our house just wasn’t a viable option any more. Here in Cardiff, we’ve been lucky enough to have several co-working spaces open locally, but for me I prefer being able to switch off background noise and clear my head when I really need to knuckle down and focus. Around the same time, we made some major changes to the back of our house and garden which meant that there was space enough for a desk in our sunroom which overlooks it. I now spend 90% of my working time looking out over our little green space, which makes for a welcome break from staring at my screen and gives me a self-contained and more importantly, quiet environment in which to think. I also get to enjoy the space more overlooking the various wildlife that visits during the day. It’s funny how good a little bird taking a dust bath every now and again will make you feel.

Organise Your Tasks

I use trello for organising tasks I want to get done, with a board for each project. These are organised in descending priority, using trellos card defaults of “To Do”, “Done” and “Doing” to track what I’ve achieved for a project. If whilst during the course of one task, I realise something needs doing over and above the scope of the task I’m currently working on, I’ll add it to my todo list and work on it when all other tasks with a higher priority have been completed. This strategy works well for me in terms of being able to blast through a whole heap of development tasks without having to think too much about what I need to do next.

Plan Your Next Day Before Leaving Your Desk

I like to end my day at a distinct break between tasks. If my day ends at a point where something is incomplete, I’ll be sure to keep it in my to-do list for the following day, where I can come back to it. Before I leave my desk each day I’ll generally try and plan out what makes sense to cover (given the time I have) in the following working day. This allows me to hit the ground running each day, without any getting up to speed time first thing in the morning.

Track Your Time

Tracking my time is important not only for my client work, but also my own projects. As well as giving me exact totals for invoicing, it allows me to compare estimates against the reality of a project and all the unforeseen problems that may arise during the course of it. My time tracking is a simple project based on/off approach, where I use a custom tool I developed myself.

Eliminate Distractions

Although obvious, trying to cut down on distractions pays dividends. Switch off tweetdeck, close skype and either disable notifications on your phone or (my favourite) put it out of your sight completely. I don’t tend to pay any thought to my phone if I can’t see it, and it’s like a nervous twitch to pick it up and check whether anything has happened in the last 5 mins. When not aware it’s an option, I probably get twice as much work done. It’s easy to kid yourself that checking devices like this is part of your work, but when at the detriment of your day’s schedule you need to switch off and focus on the bigger picture.

These are just a few measures I take to be more productive in my day - I’d welcome any tips other freelancers have for their own situations.

Tagged productivity, | Leave a comment

Porting a Wordpress blog to Jekyll: Part 2

02 Jun 2014

In the second of my posts in porting a wordpress blog over to jekyll, I outline how I’ve replicated wordpress’s default permalink structure on my own blog.

Creating Category and Tag Pages

Jekyll doesn’t create category or tag index pages for those categories listed in your _posts source. Instead, you’ll need to use a plugin to recreate them. I used the tutorial here as the basis for my category/tag generator, with my plugins/generate_cats_and_tags.rb source below:

module Jekyll
    class CatsAndTags < Generator
        def generate(site)
          site.categories.each do |category|
            build_subpages(site, "category", category)

          site.tags.each do |tag|
            build_subpages(site, "tag", tag)

        # Do the actual generation.
        def build_subpages(site, type, posts)
          posts[1] = posts[1].sort_by { |p| }
          atomize(site, type, posts)
          paginate(site, type, posts)

        def atomize(site, type, posts)
          path = "/#{type}/#{posts[0]}"
          atom =, site.source, path, type, posts[0], posts[1])
          site.pages << atom

        def paginate(site, type, posts)
          pages = Pager.calculate_pages(posts[1], site.config['paginate'].to_i)
          (1..pages).each do |num_page|
            pager =, num_page, posts[1], pages)
            slug = posts[0].gsub(' ', '-')
            base_path = "/#{type}/#{slug}"
            path = base_path
            if num_page > 1
              path += "/page/#{num_page}"
            newpage =, site.source, path, base_path, type, posts[0])
            newpage.pager = pager
            site.pages << newpage


    class GroupSubPage < Page
        def initialize(site, base, dir, base_path, type, val)
          @site = site
          @base = base
          @dir = dir
          @name = 'index.html'

          self.read_yaml(File.join(base, '_layouts'), "group_index.html")
[type] = val
['base'] = base_path

    class AtomPage < Page
        def initialize(site, base, dir, type, val, posts)
            @site = site
            @base = base
            @dir = dir
            @name = 'atom.xml'

            self.read_yaml(File.join(base, '_layouts'), "group_atom.xml")
  [type] = val
  ["grouptype"] = type
  ["posts"] = posts[0..9]

I chose to pass in an extra parameter to the Pager, defining the “base_path” for which an index page has been generated. This enables absolute links to pages and prevents situations like /category/javascript/category/javascript/page/1, which occur when relative pagination is generated when on a category page.

A view making use of it would look like the following:

<div class="pagination">
        {% if paginator.previous_page %}
          <a href="{{ page.base }}/page/{{ paginator.previous_page }}" class="previous">Previous</a>
        {% else %}
          <span class="previous">Previous</span>
        {% endif %}
        <span class="page_number ">Page: {{ }} of {{ paginator.total_pages }}</span>
        {% if paginator.next_page %}
          <a href="{{ page.base }}/page/{{ paginator.next_page }}" class="next">Next</a>
        {% else %}
          <span class="next ">Next</span>
        {% endif %}

Creating Archive Pages

In a similar fashion, Jekyll doesn’t create pages or pagination for previous years or months. Even if they are not oft used by others, I find it useful myself to hit up my archives for previous years on occasion and laugh at the random work I did for my undergraduate.

I created the following plugin to generate indexes at /{year} /{year}/{month} and /{year}/page/{pageNo} and /{year}/{month}/page/{pageNo} if necessary.

module Jekyll

  class ArchiveGenerator < Generator
    safe true
    def generate(site)
      if site.layouts.key? 'archive_index'
        site.posts.group_by{ |c| {"month" =>, "year" =>} }.each do |period, posts|
          posts = posts.sort_by { |p| }
          archive_dir = File.join(period["year"].to_s(), "%02d" % period["month"].to_s())
          paginate(site, archive_dir, posts)
        site.posts.group_by{ |c| {"year" =>} }.each do |period, posts|
          posts = posts.sort_by { |p| }
          archive_dir = period["year"].to_s()
          paginate(site, archive_dir, posts)

    def paginate(site, dir, posts)
      pages = Pager.calculate_pages(posts, site.config['paginate'].to_i)
      (1..pages).each do |num_page|
        pager =, num_page, posts, pages)
        archive_path = "/" + dir
        path = archive_path
        if num_page > 1
          path += "/page/#{num_page}"
        newpage =, site.source, path, archive_path, posts)
        newpage.pager = pager
        site.pages << newpage


  class ArchiveIndex < Page
    def initialize(site, base, dir, base_path, posts)
      @site = site
      @base = base
      @dir = dir
      @name = 'index.html'

      self.read_yaml(File.join(base, '_layouts'), 'archive_index.html')['base'] = base_path

The layout of the paginator for the archives is the same as that for categories and tags.

That’s it for my jekyll roundup, I other long time wordpress users find this information useful.

Tagged jekyll, static sites, wordpress, | Leave a comment

Porting a Wordpress blog to Jekyll: Part 1

20 May 2014

As my last post indicated, I recently made the decision to leave wordpress for jekyll for my blogging software of choice. There were a number of hurdles I had to overcome in order to get to a state I was happy with, emulating my previous blog structure. This first post details a few of the setup problems and how I’ve overcome them.

Using Compass for a Jekyll theme

The first problem I hit was my use of compass to create parts of the theme I intended to use for my blog. When attempting to use jekyll-compass to enable that, I hit the following error:

Unable to activate compass-0.12.6, because sass-3.3.7 conflicts with sass (~> 3.2.19) (Gem::LoadError)

After searching for a bit I came across the following issue which detailed a solution - but unfortunately it didn’t work for me. Being somewhat of a newbie to Ruby, I didn’t realise that after creating a Gem as instructed in the fix, I actually needed to “bundle install” it. After a little more digging and tweaking against Mark Turners advice, I ended up with a Gem file like so:

source ""

gem 'sass', "~> 3.2.19"
gem 'jekyll-compass', "1.0.6"

Which has finally given me what I wanted.

Using Custom Pygments Themes for Syntax highlighting

Jekyll uses pygments for fancy pants syntax highlighting. Although an example syntax.css is linked to in the jekyll documentation, I prefer a darker theme myself. Jekyll doesn’t tell you it’s possible to generate any one of the numerous pygments styles like this:

pygmentize -f html -S monokai -a .highlight > monokai.css

I’ve used the monokai theme for my own highlighting. There are demos of each of the themes on the pygments site - here is an example. You can then use that as the basis for your own custom highlighting. I’ve created each one of the 19 possible themes and put them up on github.

Moving to Disqus Commenting

Given I now had a static site, I needed a means of continuing supporting comments. Disqus does just that by embedding comments using javascript into post pages. Adding disqus proved to be the biggest hurdle for me. I had a large number of comments from people on my blog over the years and therefore I didn’t want to lose them. After exporting my site as xml and uploading them to disqus, I finally set jekyll loose on my site along with disqus embeds, but I couldn’t see them. The problem I found after a frustrating hour or two of uploading new versions of my site over ftp, was jekyll used a trailing slash (as the post is an index within a directory) to denote links to posts. It’s possible however to do away with this using .htaccess if you’re using Apache.

Options -Multiviews +FollowSymLinks
RewriteEngine On
RewriteBase /
DirectorySlash Off

# remove the trailing slash
RewriteRule ^(.*)\/(\?.*)?$ $1$2 [R=301,L]

# rewrite /dir/file to /dir/file/index.html
RewriteRule ^([\w\/-]+)(\?.*)?$ $1/index.html$2 [L,T=application/x-httpd-html]

However, when I began using github pages, this fix didn’t work as github only serves static files and doesn’t allow use of htaccess. Instead, I had to resign to the fact that I would have to have trailing slashes (apparently they’re quicker anyway). This then meant I had to use the Redirect Crawler option of disqus’s “Migrate Threads” wizard (seen below) to crawl my new blog on github and determine where the posts were now located.

In my next post I’ll go through how I use plugins to support archive, category and tag pages in jekyll.

Tagged jekyll, static sites, wordpress, disqus, pygments, | Leave a comment

Bye Bye Wordpress

18 May 2014

I’ve finally made the move to jekyll for building this site. It is now hosted on github pages, comments are handled by disqus and my post source is written in markdown. My entire site is visible on github and revision control for post entries is handled there too.

What finally convinced me with the release of jekyll 2 was the introduction of native sass support. Originally, the prose theme I’m using for my site was using scss, which I later ported to a wordpress theme in order to blog with it. I had the scss for the original design available and therefore thought the jump to using jekyll wouldn’t be that great (or so I thought - overlooking all the features jekyll doesn’t support compared to wordpress). I’m going to blog individually about the pieces of the puzzle in other posts as there are number of things that tripped me up along the way.

But for now, I’d like to bid a fond farewell to wordpress - my go to blogging software for the last 10 years. You once were diminutive, got out of my way and let my voice be heard. That’s no longer the case. These days the only time we speak is when you want me to update you. I’ve got better things to do. Theres a ton of features the length of my arm which I’ve never used and the majority of features which I use rarely. I long for those simpler days once again. You’ve served me well, but I’ve moved on.

Tagged jekyll, static sites, wordpress, | Leave a comment

Copyright Law Finally Aligns with Me

07 Apr 2014

On June 1st 2014, some much needed changes are being made to exceptions to copyright law which amongst other things, will allow conversion of personal media between file formats.

Finally, we’ll able to make personal conversions of digital media (at least they will be now counted as legal copies). I’ve long made copies of my cd’s to listen to whilst coding (iTunes allows me to do so simply) – but it is not currently legal to move these files to another storage medium, such as an mp3 player. The fact is that most people have been ripping cds and copying them to iPods since it was technically possible, but music companies have never prosecuted anyone as the implications would stem far and wide and would the costs would too prohibitive to be able to enforce them.

It’s also not currently legal to rip movies to another format. So copying a dvd to a mkv file to play elsewhere is construed illegal. The fact movie studios put protection in place on their dvds to prevent you from doing so puts most people off doing so anyway. From June 1st this also changes so it will also be legal (but probably will be as difficult due to the copy protection in place). The guidance doesn’t specifically mention blu-rays by name, but it does say “The exception will apply to any copies you have bought, other than computer programs” – which I see to include blu-rays. However, it does also mention that copy protection may still be in place on those formats. Which you can raise a complaint to the secretary of state about if you think it’s too restrictive (good luck getting a response there!).

I’m a big fan of said changes, mainly due to the fact I own a huge amount of discs which aren’t currently allowed to be any format other than that they were distributed in. DVD’s, CD’s and Vinyl(!). I’ve found this frustrating, as my own stance is I should be able to manipulate the media to my hearts content within my own 4 walls. In fact, in order to listen to myself practicing when I used to dj, I need to make recordings which change their format. The fact that I’ll be able to do this within the law makes me a very happy chap indeed. Up until now, the law has been fairly grey on the matter, but hasn’t prosecuted anyone for format conversion (as far as I’m aware).

The new guidance is quick to point out that it’ll still be illegal to distribute the media you create – You have to “own” the media you’re converting. Therefore duplicating a friends mp3 collection at work from their hard drive will still be illegal. If you sell the original format from which you made copies, then your copies will again be illegal. Again this aligns with how I feel things should be done. I feel like I should be paying someone for the entertainment I enjoy from said media. The artist/record labels decide a price and that’s what I should pay – but I don’t feel like they can make me pay multiple times for the same thing, especially if I can create said formats from media I already own. If you hold a copy but haven’t paid for it, I feel it fair for it to be deemed illegal, however possible it is technically to achieve.

In summary, I feel these changes are great (but long overdue).

You can read a full summary of changes to consumers issued by the Intellectual Property Office here. Amusingly, the document explains you may be affected if you “read books, watch films or listen to music” – or my favourite “use electronic devices”. I guess that covers anyone reading this then.

Tagged copyright, law, Music, | Leave a comment

Shipping in March: Weeks 2 & 3

23 Mar 2014

So, anybody paying close attention may have noticed I’ve skipped a week on updating my progress on shipping in March. There wasn’t much to report in week 2 aside from I was busily updating my Nifty Digits site. This hasn’t yet gone live, mainly due to some restrictions on current client projects and publishing about my previous work. I hope to be able to publish it before the end of the month. I spent approximately 3 days on this, 1 on client work and 1 on working on Hourglass.

This past week however I’ve been working on a revamp for Fair & Bare and breaking out the shopping software I built for it into a new product. The reasoning for this is two-fold – we have stock for Fair & Bare we want to rave about and sell and I spent a long time building a shopping cart system that’s only ever been used by me! It makes sense (at least to me) that making this byproduct available (as per the 37signals mantra). Fair & Bare has existed for 7 years now and it’s backend has barely changed in that time and it’s still happily taking orders. This week has been an opportunity to rebuild it in a more robust manner, with more features and without everything that annoys me about current checkout systems.

Granted, it’s currently small and will probably won’t compare in terms of the number of features to cart provider’s that already exist – but what I hope it will provide is a simple, easy to manage way of selling stuff online. I’ve had a huge amount of thoughts on what would be the best way to package it, but have settled on a SaaS based system, rather than self hosted. I’ve been able to use stripe to simplify the way payments are taken and I’m planning on integrating a number of other tools to make life easier for developers.

Again, it’s incomplete and not ready to release – but it is in a place that I’m able to use it as an admin. I’m planning on getting F&B using it and then releasing it on it’s own. If you’d like to see some features then please comment below and let me know.

The one thing I have realised about working on my own projects is the freedom I have to talk about it. No NDAs, no worry of treading on people’s toes, just (hopefully) helpful info. Several blog post ideas have been found over the course of the work I’ve been doing so far this month, one of which has already been published. I’m hoping I’ll finally have something to show you all before the end of this week.

Tagged ecommerce, shopping, time tracking, | Leave a comment

Shipping in March: Week 1

10 Mar 2014

I promised a progress update on how my attempt to get 4 projects shipped this month was going. On my first week, I decided to focus on my time tracking tool, hourglass. I’ve had this in the works for sometime and unfortunately, it’s fallen by the wayside to client work.

I’ve failed on my first week in getting this released to the world, but I’m far happier with how it’s working now and the value it might give to any potential user than previously. I’d had a working app and a shiny new design for it prior to last week, so first on my agenda was to bring that in and start from there. Beyond that, I bug fixed a number of known issues, followed by building out a number of reporting features which I feel are critical to have before release. It’s also allowed me to better think about the decisions I’ve made regarding implementation and whether or not it makes sense to change them at any stage soon.

Unfortunately, over this time I hit a major hurdle of my internet connection being killed due to scheduled maintenance. I had been sent a letter on this, but hadn’t clocked the date. I was lucky that in Cardiff we have a number of excellent co-working facilities that allow me to turn up unannounced and fled home for the sanctuary of Foundershub. In the end I lost probably a couple of hours to this problem and I’m glad I made the decision early on to move before I’d lost the best part of the day.

I’m going to be moving on to my next project this week as planned and move back to hourglass if time allows. I feel that experiencing the variety of these projects will hopefully allow me to continue some kind of momentum. Out of all the ones I have planned, I feel that hourglass is probably one of the larger ones too.

Tagged | Leave a comment