Cycle.js without sanity checks and comments in a single file. Don't use this, use normal Cycle.js. :-)

slim-cycle-core.js

let Rx = require(`rx`)

function makeRequestProxies(drivers) {
  let requestProxies = {}
  for (let name in drivers) {
    if (drivers.hasOwnProperty(name)) {
      requestProxies[name] = new Rx.ReplaySubject(1)
    }
  }
  return requestProxies
}

function callDrivers(drivers, requestProxies) {
  let responses = {}
  for (let name in drivers) {
    if (drivers.hasOwnProperty(name)) {
      responses[name] = drivers[name](requestProxies[name], name)
    }
  }
  return responses
}

function attachDisposeToRequests(requests, replicationSubscription) {
  Object.defineProperty(requests, `dispose`, {
    enumerable: false,
    value: () => { replicationSubscription.dispose() },
  })
  return requests
}

function makeDisposeResponses(responses) {
  return function dispose() {
    for (let name in responses) {
      if (responses.hasOwnProperty(name) &&
        typeof responses[name].dispose === `function`)
      {
        responses[name].dispose()
      }
    }
  }
}

function attachDisposeToResponses(responses) {
  Object.defineProperty(responses, `dispose`, {
    enumerable: false,
    value: makeDisposeResponses(responses),
  })
  return responses
}

function replicateMany(observables, subjects) {
  return Rx.Observable.create(observer => {
    let subscription = new Rx.CompositeDisposable()
    setTimeout(() => {
      for (let name in observables) {
        if (observables.hasOwnProperty(name) &&
          subjects.hasOwnProperty(name) &&
          !subjects[name].isDisposed)
        {
          subscription.add(
            observables[name]
              .subscribe(subjects[name].asObserver())
          )
        }
      }
      observer.onNext(subscription)
    }, 1)

    return function dispose() {
      subscription.dispose()
      for (let x in subjects) {
        if (subjects.hasOwnProperty(x)) {
          subjects[x].dispose()
        }
      }
    }
  })
}

function run(main, drivers) {
  let requestProxies = makeRequestProxies(drivers)
  let responses = callDrivers(drivers, requestProxies)
  let requests = main(responses)
  let subscription = replicateMany(requests, requestProxies).subscribe()
  let requestsWithDispose = attachDisposeToRequests(requests, subscription)
  let responsesWithDispose = attachDisposeToResponses(responses)
  return [requestsWithDispose, responsesWithDispose]
}

let Cycle = {run, Rx: Rx}

module.exports = Cycle

This is an important measure of success.

(Kidding aside, it actually tells something about the simplicity)

Just one problem in comparison to Redux:

let Rx = require('rx')