CuteStudio is based in Cambridgeshire, UK, specialising in software and audio.

We specialise in the following areas, Ember and SeeDeClip demonstrate our technology:

  • Software architecture, design and implementation
  • Graphic design, layout, user interfaces, presentation
  • Digital audio processing
  • Multithreading (Posix), buffers, caching, networking
  • Garbage collection
  • Linux (ARM/Intel), Windows (Win32), Apple OS/X (Unix)
  • Embedded software
  • Fast lightweight programming, rapid development
  • C, C++, Perl, PHP
  • Web programming (HTML/CSS/Javascript/DOM/Json/Ajax/PHP)
  • HiFi audio consultancy and design

Because much of Cutestudio is in our software products they tell you far more about us than anything else could:


The idea is to keep the big picture and long term in view at all times. This means software structure, layers and modularity comes first and changes and additions should never break the architecture, but things can be re-architectured to manage the new requirements.

The correct architecture will allow progress of the actual purpose of the software to continue unimpeded. The driving aim of 'what should the software do' is therefore never a reason to break an architecture, but should instead drive it to be better.

If you ignore this you end up in an unmaintainable swamp, elegance and design always wins out.

Software and updates

Software is different to hardware, the first thing software needs is to be updated. Essentially being able to update software is more important than if it works, because the latter can be fixed as long as the former is possible.

Putting updates first is something that an internet website does intrinsically, but it's not always so straightforward with programs that live on devices, this is why SeeDeClip4 had the update mechanism built right in right from the start. While a song is playing on a Linux slave you can update SeeDeClip4 from a web browser without even interrupting your music.

SeeDeClip4 is actually two programs in one, it's both a boot program for itself and the application, the initial installer that is manually downloaded and installed is just a reduced version of SeeDeClip4.

The website/app philosophy

Software is traditionally stuck on one type of device and has to be written just for that device class, with its limitations, menus and quirks.
User facing software can be distilled to become just two tasks: Presentation of data and control.

Essentially modern web technology already gives us the tools for these:


HTML/CSS is perfect for presentation, it's difficult to think of a better format with content and style aspects, markup for flow control and layout - it's all there already in HTML.
Want to display a picture? Want to change the background? Want to add an object and have everything on the page adjust? HTML and CSS make it trivial.


HTML also has check boxes, text boxes, sliders, buttons, radio buttons, selections, along with Javascript, Ajax and DOM.

So we have a well supported industry standard for presentation and control, but web technology has another large benefit: you don't have to run the app from the device it's installed on..

This is why SeeDeClip4 is a website.
Additionally the last thing HiFi needs is a PC sitting next to it, which means networking must be integral to the program and few programs network as well as a web server...

A change of direction - push vs pull architecture

With HTTP web requests they all come in at once, they may or may not be a complete set and all want to be drawn now. I.e. you have to draw them when you are asked, not as and when you are ready.

Push: Out with the old..

Traditionally programs get started, do their thing - perhaps with some user input in the meantime - and then stop.
Like Lame, a program that can convert a WAV file to MP3, or Paint, where the user loads some memory, fills it in a bit and then saves it to disc.
So the program basically runs and along the way the user can get to instruct it and the program gets to output data, graphs etc. This is the old 'push' model of computer programs and how SeeDeClip 1,2 and 3 basically operated.

Pull: In with the new

A web site is a demand based system where the demand can come and go at a whim and people want a responsive system. For pages like the SeeDeClip4 Studio page the challenge is to display before and after histograms and waveforms with a zoom encompassing both of them. This is 5 graphs at the same time, plus analysis results, controls with current settings all at the same time.

You could queue the requests, work out which one needed to be done first and then display the before data, process the file, display the analysis and then display the after results and serve all the other little requests like static images and icons on the page. But at the same time someone else in the house could be demanding a stream of a processed track, perhaps a background scan is happening and you've also got the question of available memory.

Clearly a demand based system needs a completely different software architecture that involves non blocking multi-threading, smart buffering and caching in a managed but intricate dance of CPU power and memory resources as it services active requests and aborts discarded ones.

Ember and SeeDeClip4 are more like operating systems than applications.

Object oriented programming

Ember and SeeDeClip use an object based approach in many areas and in a multithreaded environment there's often a requirement for garbage collected (GC) memory allocations to allow objects to be both safely managed and properly freed.

Formalising that in C++ can however cause issues of speed and complexity that simply don't need to exist with a correctly written C program. Additionally the C++ standard library has a huge space overhead. There is no message passing or anything else to slow our software down and the compact size means a better cache fit in CPUs which also helps the speed.

The combination of C and our selective use of GC gives us the best of both worlds, GC is essential in languages like Java, PHP etc but also unlocks huge potential in C in terms of giving the freedom to allocate memory for requests as needed without having to worry about freeing it all at the end, it being collected automatically at the end of the request by Ember (or explicitly at the end of an operation).

As a result we can run a very high speed and compact system skipping much of the burden in traditional C programs for memory management. Results are also tested against Valgrind to ensure there's not a single bad memory access and all memory is properly freed or accounted for.

Products and software layers

Ember - a compact, efficient and useful webserver, no PHP required..

Ember is an extremely powerful, efficient and compact multithreaded webserver with a fully integrated and modular control system built right in without equal today. There is no product that can do so much, so fast with such an efficient memory footprint.
For embedded products that need a webserver Ember is the best choice bar none.

The Ember product has a number of layers and makes good use of our utility library.

  • Util: A thread safe utility/support library (C, 6689 lines)
    • String manipulation
    • Date, time and number formatting
    • Buffer library with blocking/size management
    • UTF text management
    • Generic hashing library for fast lookups
    • OS/file functions and veneers
    • Logging system for errors and activity
    • Base 64 codec
    • Checksumming
    • Garbage collection (GC)

  • Ember HTTP web server (sits on top of Util, C, 9439 lines)
    • Web graphics library (Canvas)
    • CTL (our in-house fast PHP surrogate)
    • CTL modules
      • Include - pulls other HTML/Java etc. files into a page
      • Conditionals - If/Else
      • Echo - CTL output, formatting and calling (nests)
      • Silk - wiki style HTML layout and formatting
      • Control - web controls that make the webapp behave like a program.

    • Socket library and networking
    • Json read/write routines, node trees and management.
    • Multi-threaded HTTP server
    • Config management (Json database with robust saving mechanism)
    • Save data processing (Prevents multiple rapid disk saves by taking save requirements offline)
    • wget HTTP receive function (simple HTTP for updates and artwork drag-drop)


The SeeDeClip4 product is an Ember webserver based application.

  • SeeDeClip4 (Sits on top of the Ember web server, C, 33717 lines)
    • Universal dynamic caching: Caches anything in a multithreaded environment in a minimal-blocking way.
      This caches objects (file meta data, analysis results, 'before' music segments, 'after' processed music segments, imported music files etc).
      Cache size can be modified on the fly and can adapt based on usage.

    • Track info (background analysis scan, ratings)
      • Quality ratings
      • Rating read, write, storage
      • Background scan

    • Digital Signal Processing (C, 6269 lines)
      • Histogram analysis
      • Clip analysis and repair
      • Level measurements

    • Meta data handling (C, 3737 lines)
      • Ogg vorbis
      • Flac (read, write)
      • Id3 (MP3, read, write)
      • M4a
      • WAV

    • WAV handling (C, 3109 lines)
      • File read/write (via callbacks to web or file)
      • Resampling
      • Mastering
      • Dither

    • Waveform graphing library (View)
      • Compact RMS + peak view
      • Close up waveforms
      • Markers, cursors etc.

    • Additional CTL modules
      • File exploring, library scanning, background analysis
      • Program information
      • Settings
      • Declip
      • Streaming and graphing
      • Program update
      • Export
      • Client (Remote/Slave management)

All software IP is fully owned by Cutestudio

The modularity and layered architecture allows point improvements to benefit the whole. Adding functionality is very fast, adding features is about the features themselves rather than how to integrate them into the system.

Additional IP

We also have IP for the following tasks

  • Graphics stack (for low power embedded products or research)
    • Basic graphics system (lines, boxes, clipping etc)
    • Viewport scaling graphics layer for scaling vector graphics
    • Overlapping tiled windows library - turn a basic device into one with windows, very small code size.
    • Smart menu system

All software IP is fully owned by Cutestudio

Contact us for IP licensing and consulting projects and rate.

Copyright © 2007-2023, CuteStudio
Page generated in 0.454s, Powered by Silk V1.3-0 from Cutestudio