diff --git a/Dirt.hs b/Dirt.hs
--- a/Dirt.hs
+++ b/Dirt.hs
@@ -107,7 +107,7 @@
                   |+| end (atom (fromIntegral (i+1) / fromIntegral n))
 
 striate' :: Int -> Double -> OscPattern -> OscPattern
-striate' n f p = slowcat $ map (\x -> off (fromIntegral x) p) [0 .. n-1]
+striate' n f p = cat $ map (\x -> off (fromIntegral x) p) [0 .. n-1]
   where off i p = p |+| begin (atom (slot * i) :: Pattern Double) |+| end (atom ((slot * i) + f) :: Pattern Double)
         slot = (1 - f) / (fromIntegral n)
 
diff --git a/Pattern.hs b/Pattern.hs
--- a/Pattern.hs
+++ b/Pattern.hs
@@ -77,12 +77,15 @@
 stack :: [Pattern a] -> Pattern a
 stack ps = foldr overlay silence ps
 
-cat :: [Pattern b] -> Pattern b
+cat :: [Pattern a] -> Pattern a
 cat ps = density (fromIntegral $ length ps) $ slowcat ps
 
 append :: Pattern a -> Pattern a -> Pattern a
 append a b = cat [a,b]
 
+append' :: Pattern a -> Pattern a -> Pattern a
+append' a b  = slow 2 $ cat [a,b]
+
 slowcat' ps = Pattern $ \a -> concatMap f (arcCycles a)
   where l = length ps
         f (s,e) = arc p (s,e)
@@ -92,6 +95,8 @@
 -- Concatenates so that the first loop of each pattern is played in
 -- turn, second loop of each pattern, and so on..
 
+slowcat :: [Pattern a] -> Pattern a
+slowcat [] = silence
 slowcat ps = Pattern $ \a -> concatMap f (arcCycles a)
   where l = length ps
         f (s,e) = arc (mapResultTime (+offset) p) (s',e')
@@ -181,7 +186,7 @@
 seqToRelOnsets (s, e) p = mapFsts (fromRational . (/ (e-s)) . (subtract s) . fst) $ arc (filterOffsets p) (s, e)
 
 segment :: Pattern a -> Pattern [a]
-segment p = Pattern $ \r -> groupByTime (segment' (arc p r))
+segment p = Pattern $ \(s,e) -> filter (\((s',e'),_) -> s' < e && e' > s) $ groupByTime (segment' (arc p (s,e)))
 
 segment' :: [Event a] -> [Event a]
 segment' es = foldr split es pts
diff --git a/Strategies.hs b/Strategies.hs
--- a/Strategies.hs
+++ b/Strategies.hs
@@ -15,7 +15,7 @@
 
 -- every 4 (smash 4 [1, 2, 3]) $ sound "[odx sn/2 [~ odx] sn/3, [~ hh]*4]"
 
-smash n xs p = cat $ map (\n -> slow n p') xs
+smash n xs p = slowcat $ map (\n -> slow n p') xs
   where p' = striate n p
 
 brak = every 2 (((1%4) <~) . (\x -> cat [x, silence]))
@@ -46,4 +46,4 @@
                                                    (arc p' (s,s))
                               ) (arc p a)
 
-
+whenmod a b = Pattern.when ((\t -> (t `mod` a) >= b ))
diff --git a/Stream.hs b/Stream.hs
--- a/Stream.hs
+++ b/Stream.hs
@@ -6,7 +6,7 @@
 import Sound.OSC.FD
 import Sound.OpenSoundControl
 import Control.Applicative
-import Tempo (Tempo, logicalTime, clocked)
+import Tempo (Tempo, logicalTime, clocked,clockedTick)
 import Control.Concurrent
 import Control.Concurrent.MVar
 import Pattern
@@ -64,7 +64,8 @@
 isSubset :: (Eq a) => [a] -> [a] -> Bool
 isSubset xs ys = all (\x -> elem x ys) xs
 
-tpb = 1
+tpb = 4
+bpb = 16
 
 toMessage :: OscShape -> Tempo -> Int -> (Double, OscMap) -> Maybe Message
 toMessage s change ticks (o, m) =
@@ -96,13 +97,13 @@
        s <- openUDP address port
        putStrLn $ "connected "
        let ot = (onTick s shape patternM) :: Tempo -> Int -> IO ()
-       forkIO $ clocked ot
+       forkIO $ clockedTick tpb $ ot
        return patternM
 
 stream :: String -> Int -> OscShape -> IO (OscPattern -> IO ())
 stream address port shape 
   = do patternM <- start address port shape
-       return $ \p -> do swapMVar patternM p
+       return $ \p -> do swapMVar patternM (slow bpb p)
                          return ()
 
 streamcallback :: (OscPattern -> IO ()) -> String -> Int -> OscShape -> IO (OscPattern -> IO ())
diff --git a/Tempo.hs b/Tempo.hs
--- a/Tempo.hs
+++ b/Tempo.hs
@@ -116,6 +116,30 @@
              callback t b
              loop mTempo $ b + 1
 
+clockedTick :: Int -> (Tempo -> Int -> IO ()) -> IO ()
+clockedTick tpb callback = 
+  do (mTempo, mBps) <- runClient
+     t <- readMVar mTempo
+     now <- getCurrentTime
+     let delta = realToFrac $ diffUTCTime now (at t)
+         beatDelta = bps t * delta
+         nowBeat = beat t + beatDelta
+         nextTick = ceiling (nowBeat * (fromIntegral tpb))
+         -- next4 = nextBeat + (4 - (nextBeat `mod` 4))
+     loop mTempo nextTick
+  where loop mTempo tick = 
+          do t <- readMVar mTempo
+             now <- getCurrentTime
+             let tps = (fromIntegral tpb) * bps t
+                 delta = realToFrac $ diffUTCTime now (at t)
+                 actualTick = ((fromIntegral tpb) * beat t) + (tps * delta)
+                 tickDelta = (fromIntegral tick) - actualTick
+                 delay = tickDelta / tps
+             --putStrLn $ "tick: " ++ (show tick) ++ " actualTick " ++ (show actualTick)
+             threadDelay $ floor (delay * 1000000)
+             callback t tick
+             loop mTempo $ tick + 1
+
 updateTempo :: MVar Tempo -> Maybe Double -> IO ()
 updateTempo mt Nothing = return ()
 updateTempo mt (Just bps') = do t <- takeMVar mt
diff --git a/tidal.cabal b/tidal.cabal
--- a/tidal.cabal
+++ b/tidal.cabal
@@ -7,7 +7,7 @@
 -- The package version. See the Haskell package versioning policy
 -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for
 -- standards guiding when and how versions should be incremented.
-Version:             0.2.2.6
+Version:             0.2.2.7
 
 -- A short (one-line) description of the package.
 Synopsis:            Pattern language for improvised music