diff --git a/Data/Bifoldable.hs b/Data/Bifoldable.hs
--- a/Data/Bifoldable.hs
+++ b/Data/Bifoldable.hs
@@ -18,6 +18,7 @@
   , bitraverse_
   , bifor_
   , bimapM_
+  , biforM_
   , bisequenceA_
   , bisequence_
   , biList
diff --git a/Data/Bifunctor/Apply.hs b/Data/Bifunctor/Apply.hs
new file mode 100644
--- /dev/null
+++ b/Data/Bifunctor/Apply.hs
@@ -0,0 +1,62 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Bifunctor.Apply
+-- Copyright   :  (C) 2011 Edward Kmett,
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  portable
+--
+----------------------------------------------------------------------------
+module Data.Bifunctor.Apply ( 
+  -- * Functors
+  -- * Applyable bifunctors
+    Biapply(..)
+  , (<<$>>)
+  , (<<..>>)
+  , bilift2
+  , bilift3
+  , module Data.Bifunctor
+  ) where
+
+-- import _everything_
+import Data.Bifunctor
+
+infixl 4 <<$>>, <<.>>, <<., .>>, <<..>>
+
+(<<$>>) :: (a -> b) -> a -> b
+(<<$>>) = id
+
+-- | A strong lax semi-monoidal endofunctor. 
+-- This is equivalent to an 'Applicative' without 'pure'.
+-- 
+-- Laws: 
+--
+-- > associative composition: (.) <$> u <.> v <.> w = u <.> (v <.> w)
+class Bifunctor p => Biapply p where
+  (<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d
+
+  -- | a .> b = const id <$> a <.> b
+  (.>>) :: p a b -> p c d -> p c d
+  a .>> b = bimap (const id) (const id) <<$>> a <<.>> b
+
+  -- | a <. b = const <$> a <.> b
+  (<<.) :: p a b -> p c d -> p a b
+  a <<. b = bimap const const <<$>> a <<.>> b
+
+(<<..>>) :: Biapply p => p a c -> p (a -> b) (c -> d) -> p b d
+(<<..>>) = bilift2 (flip id) (flip id) 
+
+-- | Lift a binary function into a comonad with zipping
+bilift2 :: Biapply w => (a -> b -> c) -> (d -> e -> f) -> w a d -> w b e -> w c f
+bilift2 f g a b = bimap f g <<$>> a <<.>> b
+{-# INLINE bilift2 #-}
+
+-- | Lift a ternary function into a comonad with zipping
+bilift3 :: Biapply w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h
+bilift3 f g a b c = bimap f g <<$>> a <<.>> b <<.>> c
+{-# INLINE bilift3 #-}
+
+instance Biapply (,) where
+  (f, g) <<.>> (a, b) = (f a, g b)
diff --git a/Data/Semigroup/Bifoldable.hs b/Data/Semigroup/Bifoldable.hs
new file mode 100644
--- /dev/null
+++ b/Data/Semigroup/Bifoldable.hs
@@ -0,0 +1,68 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Semigroup.Foldable
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  portable
+--
+----------------------------------------------------------------------------
+module Data.Semigroup.Bifoldable
+  ( Bifoldable1(..)
+  , bitraverse1_
+  , bifor1_
+  , bisequenceA1_
+  , bifoldMapDefault1
+  ) where
+
+import Prelude hiding (foldr)
+import Data.Bifoldable
+import Data.Functor.Apply
+import Data.Semigroup
+import Data.Monoid
+
+class Bifoldable t => Bifoldable1 t where
+  bifold1 :: Semigroup m => t m m -> m
+  bifold1 = bifoldMap1 id id
+
+  bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> t a b -> m
+  bifoldMap1 f g = maybe (error "bifoldMap1") id . getOption . bifoldMap (Option . Just . f) (Option . Just . g)
+
+instance Bifoldable1 Either where
+  bifoldMap1 f _ (Left a) = f a
+  bifoldMap1 _ g (Right b) = g b
+
+instance Bifoldable1 (,) where
+  bifoldMap1 f g (a, b) = f a <> g b
+
+newtype Act f a = Act { getAct :: f a }
+
+instance Apply f => Semigroup (Act f a) where
+  Act a <> Act b = Act (a .> b)
+
+instance Functor f => Functor (Act f) where
+  fmap f (Act a) = Act (f <$> a)
+  b <$ Act a = Act (b <$ a)
+
+bitraverse1_ :: (Bifoldable1 t, Apply f) => (a -> f b) -> (c -> f d) -> t a c -> f ()
+bitraverse1_ f g t = getAct (bifoldMap1 (Act . ignore . f) (Act . ignore . g) t)
+{-# INLINE bitraverse1_ #-}
+
+bifor1_ :: (Bifoldable1 t, Apply f) => t a c -> (a -> f b) -> (c -> f d) -> f ()
+bifor1_ t f g = bitraverse1_ f g t 
+{-# INLINE bifor1_ #-}
+
+ignore :: Functor f => f a -> f ()
+ignore = (() <$)
+
+bisequenceA1_ :: (Bifoldable1 t, Apply f) => t (f a) (f b) -> f ()
+bisequenceA1_ t = getAct (bifoldMap1 (Act . ignore) (Act . ignore) t)
+{-# INLINE bisequenceA1_ #-}
+
+-- | Usable default for foldMap, but only if you define bifoldMap1 yourself
+bifoldMapDefault1 :: (Bifoldable1 t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
+bifoldMapDefault1 f g = unwrapMonoid . bifoldMap (WrapMonoid . f) (WrapMonoid . g)
+{-# INLINE bifoldMapDefault1 #-}
+
diff --git a/Data/Semigroup/Bitraversable.hs b/Data/Semigroup/Bitraversable.hs
new file mode 100644
--- /dev/null
+++ b/Data/Semigroup/Bitraversable.hs
@@ -0,0 +1,39 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Semigroup.Bitraversable
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  portable
+--
+----------------------------------------------------------------------------
+module Data.Semigroup.Bitraversable
+  ( Bitraversable1(..)
+  , bifoldMap1Default
+  ) where
+
+import Control.Applicative
+import Data.Functor.Apply
+import Data.Semigroup.Bifoldable
+import Data.Bitraversable
+import Data.Bifunctor
+import Data.Semigroup
+
+class (Bifoldable1 t, Bitraversable t) => Bitraversable1 t where
+  bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> t a c -> f (t b d)
+  bitraverse1 f g  = bisequence1 . bimap f g
+
+  bisequence1 :: Apply f => t (f a) (f b) -> f (t a b)
+  bisequence1 = bitraverse1 id id
+
+bifoldMap1Default :: (Bitraversable1 t, Semigroup m) => (a -> m) -> (b -> m) -> t a b -> m
+bifoldMap1Default f g = getConst . bitraverse1 (Const . f) (Const . g)
+
+instance Bitraversable1 Either where
+  bitraverse1 f _ (Left a) = Left <$> f a
+  bitraverse1 _ g (Right b) = Right <$> g b
+
+instance Bitraversable1 (,) where
+  bitraverse1 f g (a, b) = (,) <$> f a <.> g b
diff --git a/bifunctors.cabal b/bifunctors.cabal
--- a/bifunctors.cabal
+++ b/bifunctors.cabal
@@ -1,6 +1,6 @@
 name:          bifunctors
 category:      Data, Functors
-version:       0.1
+version:       0.1.1
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -19,11 +19,16 @@
 
 library
   build-depends: 
-    base >= 4 && < 4.4
+    base >= 4 && < 4.4,
+    semigroups >= 0.5 && < 0.6,
+    semigroupoids >= 1.2.2 && < 1.3
 
   exposed-modules:
     Data.Bifunctor
+    Data.Bifunctor.Apply
     Data.Bifoldable
     Data.Bitraversable
+    Data.Semigroup.Bifoldable
+    Data.Semigroup.Bitraversable
 
   ghc-options: -Wall