diff --git a/swift-playground-action/Dockerfile b/swift-playground-action/Dockerfile
new file mode 100644
index 0000000..2133673
--- /dev/null
+++ b/swift-playground-action/Dockerfile
@@ -0,0 +1,16 @@
+FROM swift3action:base
+
+ENV DEBIAN_FRONTEND noninteractive
+
+ENV PYTHONIOENCODING utf-8
+
+RUN sudo apt-get -y install libpython2.7
+
+COPY add_dylib.py /
+
+RUN /add_dylib.py
+
+WORKDIR /swift3Action/spm-build/
+RUN /bin/bash -c "/usr/bin/swift build"
+
+CMD ["/bin/bash", "-c", "cd /swift3Action && PYTHONIOENCODING='utf-8' python -u swift3runner.py"]
diff --git a/swift-playground-action/README.md b/swift-playground-action/README.md
new file mode 100644
index 0000000..2d7d84e
--- /dev/null
+++ b/swift-playground-action/README.md
@@ -0,0 +1,77 @@
+# Enabling OpenWhisk Swift3 Action to use REPL PLayground
+
+## Test
+
+```
+./build.sh
+./run.sh
+```
+
+Then inside container run basic test
+
+```
+time /usr/bin/swift /share/test0.swift
+Hello World
+```
+
+
+and using dynamic library inside REPL calling SwiftyJSON:
+
+```
+time swift -I/swift3Action/spm-build/.build/debug -L /swift3Action/spm-build/.build/debug -lSwiftyJSON /share/test1.swift
+Hello Joe Doe
+```
+
+## Current issues - unable to build dynamic version of OpenSSL library
+
+Unable to build OpenSSL - to reproduce install editor
+
+```
+apt-get -y install nano emacs
+```
+
+Modify Package.swift
+
+```
+cd /swift3Action/spm-build/
+emacs Packages/OpenSSL-0.2.2/Package.swift
+```
+
+to add
+
+```
+products.append(Product(name: "OpenSSL", type: .Library(.Dynamic), modules: "openssl"))
+```
+
+and then run
+
+```
+root@87f331718d1e:/swift3Action/spm-build# swift build
+error: the product named OpenSSL references a module that could not be found: openssl
+fix: reference only valid modules from the product
+```
+
+
+Using
+
+```
+products.append(Product(name: "OpenSSL", type: .Library(.Dynamic), modules: "OpenSSL"))
+```
+
+leads to
+
+```
+root@87f331718d1e:/swift3Action/spm-build# swift build
+Linking ./.build/debug/libOpenSSL.so
+<unknown>:0: error: no input files
+<unknown>:0: error: build had 1 command failures
+error: exit(1): /usr/bin/swift-build-tool -f /swift3Action/spm-build/.build/debug.yaml
+```
+
+
+Optimally this should work ...
+
+```
+time swift -I/swift3Action/spm-build/.build/debug -L /swift3Action/spm-build/.build/debug -lSwiftyJSON -lOpenSSL /share/test2.swift
+<unknown>:0: error: missing required module 'OpenSSL'
+``` 
diff --git a/swift-playground-action/add_dylib.py b/swift-playground-action/add_dylib.py
new file mode 100755
index 0000000..2f27b50
--- /dev/null
+++ b/swift-playground-action/add_dylib.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+#
+# Copyright 2015-2016 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+import os
+import re
+import sys
+import json
+
+# 
+# find all paclages
+# add dylib statements cusotmized ot package name
+# rebuild all packages
+
+def procesPackageFile(packageName, path):
+    stmt = '\n\nproducts.append(Product(name: "{packageName}", type: .Library(.Dynamic), modules: "{packageName}"))'.format(packageName=packageName)
+    # only patch select packages
+    if packageName == 'SwiftyJSON' :
+        print(packageName, path, stmt)
+        with open(path, "a") as myfile:
+            myfile.write(stmt + '\n')
+
+
+
+def main():
+    print("hello friend")
+    for root, dirs, files in os.walk("/swift3Action/spm-build/Packages/"):
+        for f in files:
+            if f.endswith("Package.swift"):
+                fullPath = os.path.join(root, f)
+                parentDir = os.path.split(fullPath)[0]
+                baseDir = os.path.basename(parentDir)
+                # remove version from SwiftyJSON-14.2.0
+                m = re.match("(.*)-[\d+\.]+", baseDir)
+                packageName = m.group(1)
+                #print("baseDir="+baseDir+" packageName="+packageName)
+                procesPackageFile(packageName, fullPath)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/swift-playground-action/build.sh b/swift-playground-action/build.sh
new file mode 100755
index 0000000..9fa87e1
--- /dev/null
+++ b/swift-playground-action/build.sh
@@ -0,0 +1,5 @@
+# build docker images
+echo Building base image from OpenWhisk Swift3 Action
+(cd swift3Action; docker build -t swift3action:base .)
+echo Building Swift Playground enabled version of  OpenWhisk Swift3 Action
+docker build -t swift3action:playground .
diff --git a/swift-playground-action/run.sh b/swift-playground-action/run.sh
new file mode 100755
index 0000000..beb65d3
--- /dev/null
+++ b/swift-playground-action/run.sh
@@ -0,0 +1,6 @@
+
+
+# Need to use --privileged=true or REPL fails see:
+# https://bugs.swift.org/browse/SR-54
+
+docker run --privileged=true -it -v  $(pwd):/share  swift3action:playground /bin/bash
diff --git a/swift-playground-action/swift3Action/Dockerfile b/swift-playground-action/swift3Action/Dockerfile
new file mode 100644
index 0000000..2f2fb4b
--- /dev/null
+++ b/swift-playground-action/swift3Action/Dockerfile
@@ -0,0 +1,68 @@
+# Dockerfile for swift actions, overrides and extends ActionRunner from actionProxy
+# This Dockerfile is partially based on: https://github.com/swiftdocker/docker-swift/
+FROM buildpack-deps:trusty
+
+ENV DEBIAN_FRONTEND noninteractive
+
+# Upgrade and install basic Python dependencies
+RUN apt-get -y purge \
+ && apt-get -y update \
+ && apt-get -y install --fix-missing python2.7 python-gevent python-flask \
+\
+# Upgrade and install Swift dependencies
+ && apt-get -y install --fix-missing build-essential curl wget libicu-dev \
+\
+# Install zip for compiling Swift actions
+ && apt-get -y install zip \
+\
+# Clean up
+ && apt-get clean
+
+# Install clang manually, since SPM wants at least Clang 3-6
+RUN cd / &&\
+(curl -L -k http://llvm.org/releases/3.6.2/clang+llvm-3.6.2-x86_64-linux-gnu-ubuntu-14.04.tar.xz | tar xJ) &&\
+cp -r /clang+llvm-3.6.2-x86_64-linux-gnu-ubuntu-14.04/* /usr/ &&\
+rm -rf /clang+llvm-3.6.2-x86_64-linux-gnu-ubuntu-14.04
+
+RUN update-alternatives --install /usr/bin/g++ g++ /usr/bin/clang++ 20
+RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/clang 20
+
+# Install Swift keys
+RUN wget --no-verbose -O - https://swift.org/keys/all-keys.asc | gpg --import - && \
+    gpg --keyserver hkp://pool.sks-keyservers.net --refresh-keys Swift
+
+# Install Swift Ubuntu 14.04 Snapshot
+#https://swift.org/builds/swift-3.0.1-release/ubuntu1404/swift-3.0.1-RELEASE/swift-3.0.1-RELEASE-ubuntu14.04.tar.gz
+
+ENV SWIFT_VERSION 3.0.2
+ENV SWIFT_RELEASE_TYPE RELEASE
+ENV SWIFT_PLATFORM ubuntu14.04
+
+RUN SWIFT_ARCHIVE_NAME=swift-$SWIFT_VERSION-$SWIFT_RELEASE_TYPE-$SWIFT_PLATFORM && \
+    SWIFT_URL=https://swift.org/builds/swift-$SWIFT_VERSION-$(echo "$SWIFT_RELEASE_TYPE" | tr '[:upper:]' '[:lower:]')/$(echo "$SWIFT_PLATFORM" | tr -d .)/swift-$SWIFT_VERSION-$SWIFT_RELEASE_TYPE/$SWIFT_ARCHIVE_NAME.tar.gz && \
+    echo $SWIFT_URL && \
+    wget --no-verbose $SWIFT_URL && \
+    wget --no-verbose $SWIFT_URL.sig && \
+    gpg --verify $SWIFT_ARCHIVE_NAME.tar.gz.sig && \
+    tar -xzf $SWIFT_ARCHIVE_NAME.tar.gz --directory / --strip-components=1 && \
+    rm -rf $SWIFT_ARCHIVE_NAME* /tmp/* /var/tmp/*
+
+# Add the action proxy
+RUN mkdir -p /actionProxy
+ADD actionproxy.py /actionProxy
+
+# Add files needed to build and run action
+RUN mkdir -p /swift3Action
+ADD epilogue.swift /swift3Action
+ADD buildandrecord.py /swift3Action
+ADD swift3runner.py /swift3Action
+ADD spm-build /swift3Action/spm-build
+
+
+# Build kitura net
+RUN touch /swift3Action/spm-build/main.swift
+RUN python /swift3Action/buildandrecord.py; rm /swift3Action/spm-build/.build/release/Action
+#RUN cd /swift3Action/spm-build; swift build -c release; rm /swift3Action/spm-build/.build/release/Action
+ENV FLASK_PROXY_PORT 8080
+
+CMD ["/bin/bash", "-c", "cd /swift3Action && PYTHONIOENCODING='utf-8' python -u swift3runner.py"]
diff --git a/swift-playground-action/swift3Action/README.md b/swift-playground-action/swift3Action/README.md
new file mode 100644
index 0000000..e5e454d
--- /dev/null
+++ b/swift-playground-action/swift3Action/README.md
@@ -0,0 +1,37 @@
+Skeleton for "docker actions"
+================
+
+The `dockerskeleton` base image is useful for actions that run scripts (e.g., bash, perl, python)
+and compiled binaries or, more generally, any native executable. It provides a proxy service
+(using Flask, a Python web microframework) that implements the required `/init` and `/run` routes
+to interact with the OpenWhisk invoker service. The implementation of these routes is encapsulated
+in a class named `ActionRunner` which provides a basic framework for receiving code from an invoker,
+preparing it for execution, and then running the code when required.
+
+The initialization of the `ActionRunner` is done via `init()` which receives a JSON object containing
+a `code` property whose value is the source code to execute. It writes the source to a `source` file.
+This method also provides a hook to optionally augment the received code via an `epilogue()` method,
+and then performs a `build()` to generate an executable. The last step of the initialization applies
+`verify()` to confirm the executable has the proper permissions to run the code. The action runner
+is ready to run the action if `verify()` is true.
+
+The default implementations of `epilogue()` and `build()` are no-ops and should be overridden as needed.
+The base image contains a stub added which is already executable by construction via `docker build`.
+For language runtimes (e.g., C) that require compiling the source, the extending class should run the
+required source compiler during `build()`.
+
+The `run()` method runs the action via the executable generated during `init()`. This method is only called
+by the proxy service if `verify()` is true. `ActionRunner` subclasses are encouraged to override this method
+if they have additional logic that should cause `run()` to never execute. The `run()` method calls the executable
+via a process and sends the received input parameters (from the invoker) to the action via the command line
+(as a JSON string argument). Additional properties received from the invoker are passed on to the action via
+environment variables as well. To augment the action environment, override `env()`.
+
+By convention the action executable may log messages to `stdout` and `stderr`. The proxy requires that the last
+line of output to `stdout` is a valid JSON object serialized to string if the action returns a JSON result.
+A return value is optional but must be a JSON object (properly serialized) if present.
+
+For an example implementation of an `ActionRunner` that overrides `epilogue()` and `build()` see the
+[Swift 3](../swift3Action/swift3runner.py) action proxy. An implementation of the runner for Python actions
+is available [here](../pythonAction/pythonrunner.py). Lastly, an example Docker action that uses `C` is
+available in this [example](../../sdk/docker/Dockerfile).
diff --git a/swift-playground-action/swift3Action/actionproxy.py b/swift-playground-action/swift3Action/actionproxy.py
new file mode 100644
index 0000000..c68231f
--- /dev/null
+++ b/swift-playground-action/swift3Action/actionproxy.py
@@ -0,0 +1,271 @@
+"""Executable Python script for a proxy service to dockerSkeleton.
+
+Provides a proxy service (using Flask, a Python web microframework)
+that implements the required /init and /run routes to interact with
+the OpenWhisk invoker service.
+
+The implementation of these routes is encapsulated in a class named
+ActionRunner which provides a basic framework for receiving code
+from an invoker, preparing it for execution, and then running the
+code when required.
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"""
+
+import sys
+import os
+import json
+import subprocess
+import codecs
+import flask
+from gevent.wsgi import WSGIServer
+import zipfile
+import io
+import base64
+
+
+class ActionRunner:
+    """ActionRunner."""
+    LOG_SENTINEL = 'XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX'
+
+    # initializes the runner
+    # @param source the path where the source code will be located (if any)
+    # @param binary the path where the binary will be located (may be the
+    # same as source code path)
+    def __init__(self, source=None, binary=None):
+        defaultBinary = '/action/exec'
+        self.source = source if source else defaultBinary
+        self.binary = binary if binary else defaultBinary
+
+    def preinit(self):
+        return
+
+    # extracts from the JSON object message a 'code' property and
+    # writes it to the <source> path. The source code may have an
+    # an optional <epilogue>. The source code is subsequently built
+    # to produce the <binary> that is executed during <run>.
+    # @param message is a JSON object, should contain 'code'
+    # @return True iff binary exists and is executable
+    def init(self, message):
+        def prep():
+            self.preinit()
+            if 'code' in message and message['code'] is not None:
+                binary = message['binary'] if 'binary' in message else False
+                if not binary:
+                    return self.initCodeFromString(message)
+                else:
+                    return self.initCodeFromZip(message)
+            else:
+                return False
+
+        if prep():
+            try:
+                # write source epilogue if any
+                # the message is passed along as it may contain other
+                # fields relevant to a specific container.
+                if self.epilogue(message) is False:
+                    return False
+                # build the source
+                if self.build(message) is False:
+                    return False
+            except Exception:
+                return False
+        # verify the binary exists and is executable
+        return self.verify()
+
+    # optionally appends source to the loaded code during <init>
+    def epilogue(self, init_arguments):
+        return
+
+    # optionally builds the source code loaded during <init> into an executable
+    def build(self, init_arguments):
+        return
+
+    # @return True iff binary exists and is executable, False otherwise
+    def verify(self):
+        return (os.path.isfile(self.binary) and
+                os.access(self.binary, os.X_OK))
+
+    # constructs an environment for the action to run in
+    # @param message is a JSON object received from invoker (should
+    # contain 'value' and 'api_key' and other metadata)
+    # @return an environment dictionary for the action process
+    def env(self, message):
+        # make sure to include all the env vars passed in by the invoker
+        env = os.environ
+        for p in ['api_key', 'namespace', 'action_name', 'activation_id', 'deadline']:
+            if p in message:
+                env['__OW_%s' % p.upper()] = message[p]
+        return env
+
+    # runs the action, called iff self.verify() is True.
+    # @param args is a JSON object representing the input to the action
+    # @param env is the environment for the action to run in (defined edge
+    # host, auth key)
+    # return JSON object result of running the action or an error dictionary
+    # if action failed
+    def run(self, args, env):
+        def error(msg):
+            # fall through (exception and else case are handled the same way)
+            sys.stdout.write('%s\n' % msg)
+            return (502, {'error': 'The action did not return a dictionary.'})
+
+        try:
+            input = json.dumps(args)
+            p = subprocess.Popen(
+                [self.binary, input],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env)
+        except Exception as e:
+            return error(e)
+
+        # run the process and wait until it completes.
+        # stdout/stderr will always be set because we passed PIPEs to Popen
+        (o, e) = p.communicate()
+
+        # stdout/stderr may be either text or bytes, depending on Python
+        # version, so if bytes, decode to text. Note that in Python 2
+        # a string will match both types; so also skip decoding in that case
+        if isinstance(o, bytes) and not isinstance(o, str):
+            o = o.decode('utf-8')
+        if isinstance(e, bytes) and not isinstance(e, str):
+            e = e.decode('utf-8')
+
+        # get the last line of stdout, even if empty
+        lastNewLine = o.rfind('\n', 0, len(o)-1)
+        if lastNewLine != -1:
+            # this is the result string to JSON parse
+            lastLine = o[lastNewLine+1:].strip()
+            # emit the rest as logs to stdout (including last new line)
+            sys.stdout.write(o[:lastNewLine+1])
+        else:
+            # either o is empty or it is the result string
+            lastLine = o.strip()
+
+        if e:
+            sys.stderr.write(e)
+
+        try:
+            json_output = json.loads(lastLine)
+            if isinstance(json_output, dict):
+                return (200, json_output)
+            else:
+                return error(lastLine)
+        except Exception:
+            return error(lastLine)
+
+    # initialize code from inlined string
+    def initCodeFromString(self, message):
+        with codecs.open(self.source, 'w', 'utf-8') as fp:
+            fp.write(message['code'])
+        return True
+
+    # initialize code from base64 encoded archive
+    def initCodeFromZip(self, message):
+        try:
+            bytes = base64.b64decode(message['code'])
+            bytes = io.BytesIO(bytes)
+            archive = zipfile.ZipFile(bytes)
+            archive.extractall(os.path.dirname(self.source))
+            archive.close()
+            return True
+        except Exception as e:
+            print('err', str(e))
+            return False
+
+proxy = flask.Flask(__name__)
+proxy.debug = False
+runner = None
+
+
+def setRunner(r):
+    global runner
+    runner = r
+
+
+@proxy.route('/init', methods=['POST'])
+def init():
+    message = flask.request.get_json(force=True, silent=True)
+    if message and not isinstance(message, dict):
+        flask.abort(404)
+    else:
+        value = message.get('value', {}) if message else {}
+
+    if not isinstance(value, dict):
+        flask.abort(404)
+
+    try:
+        status = runner.init(value)
+    except Exception as e:
+        status = False
+
+    if status is True:
+        return ('OK', 200)
+    else:
+        response = flask.jsonify({'error': 'The action failed to generate or locate a binary. See logs for details.'})
+        response.status_code = 502
+        return complete(response)
+
+
+@proxy.route('/run', methods=['POST'])
+def run():
+    def error():
+        response = flask.jsonify({'error': 'The action did not receive a dictionary as an argument.'})
+        response.status_code = 404
+        return complete(response)
+
+    message = flask.request.get_json(force=True, silent=True)
+    if message and not isinstance(message, dict):
+        return error()
+    else:
+        args = message.get('value', {}) if message else {}
+        if not isinstance(args, dict):
+            return error()
+
+    if runner.verify():
+        try:
+            code, result = runner.run(args, runner.env(message or {}))
+            response = flask.jsonify(result)
+            response.status_code = code
+        except Exception as e:
+            response = flask.jsonify({'error': 'Internal error. {}'.format(e)})
+            response.status_code = 500
+    else:
+        response = flask.jsonify({'error': 'The action failed to locate a binary. See logs for details.'})
+        response.status_code = 502
+    return complete(response)
+
+
+def complete(response):
+    # Add sentinel to stdout/stderr
+    sys.stdout.write('%s\n' % ActionRunner.LOG_SENTINEL)
+    sys.stdout.flush()
+    sys.stderr.write('%s\n' % ActionRunner.LOG_SENTINEL)
+    sys.stderr.flush()
+    return response
+
+
+def main():
+    port = int(os.getenv('FLASK_PROXY_PORT', 8080))
+    server = WSGIServer(('', port), proxy, log=None)
+    server.serve_forever()
+
+if __name__ == '__main__':
+    setRunner(ActionRunner())
+    main()
diff --git a/swift-playground-action/swift3Action/build.gradle b/swift-playground-action/swift3Action/build.gradle
new file mode 100644
index 0000000..0148e31
--- /dev/null
+++ b/swift-playground-action/swift3Action/build.gradle
@@ -0,0 +1,13 @@
+ext.dockerImageName = 'swift3action'
+apply from: '../../gradle/docker.gradle'
+distDocker.dependsOn 'copyProxy'
+distDocker.finalizedBy('rmProxy')
+
+task copyProxy(type: Copy) {
+    from '../actionProxy/actionproxy.py'
+    into './actionproxy.py'
+}
+
+task rmProxy(type: Delete) {
+    delete 'actionproxy.py'
+}
diff --git a/swift-playground-action/swift3Action/buildandrecord.py b/swift-playground-action/swift3Action/buildandrecord.py
new file mode 100644
index 0000000..c83c024
--- /dev/null
+++ b/swift-playground-action/swift3Action/buildandrecord.py
@@ -0,0 +1,76 @@
+"""Python to generate build script.
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"""
+from __future__ import print_function
+import os
+import sys
+from subprocess import check_output
+
+# Settings
+COMPILE_PREFIX = "/usr/bin/swiftc -module-name Action "
+LINKER_PREFIX = "/usr/bin/swiftc -Xlinker '-rpath=$ORIGIN' " \
+                "'-L/swift3Action/spm-build/.build/release' " \
+                "-o '/swift3Action/spm-build/.build/release/Action'"
+GENERATED_BUILD_SCRIPT = "/swift3Action/spm-build/swiftbuildandlink.sh"
+SPM_DIRECTORY = "/swift3Action/spm-build"
+BUILD_COMMAND = ["swift", "build", "-v", "-c", "release"]
+
+# Build Swift package and capture step trace
+print("Building action")
+out = check_output(BUILD_COMMAND, cwd=SPM_DIRECTORY)
+print("action built. Decoding compile and link commands")
+
+# Look for compile and link commands in step trace
+compileCommand = None
+linkCommand = None
+
+buildInstructions = out.decode("utf-8").splitlines()
+
+for instruction in buildInstructions:
+    if instruction.startswith(COMPILE_PREFIX):
+        compileCommand = instruction
+
+        # add flag to quiet warnings
+        compileCommand += " -suppress-warnings"
+
+    elif instruction.startswith(LINKER_PREFIX):
+        linkCommand = instruction
+
+# Create build script if found, exit otherwise
+if compileCommand is not None and linkCommand is not None:
+    print("Success, command and link commands found.")
+    with open(GENERATED_BUILD_SCRIPT, "a") as buildScript:
+        buildScript.write("#!/bin/bash\n")
+        buildScript.write("echo \"Compiling\"\n")
+        buildScript.write("%s\n" % compileCommand)
+        buildScript.write("swiftStatus=$?\n")
+        buildScript.write("echo swiftc status is $swiftStatus\n")
+        buildScript.write("if [[ \"$swiftStatus\" -eq \"0\" ]]; then\n")
+        buildScript.write("echo \"Linking\"\n")
+        buildScript.write("%s\n" % linkCommand)
+        buildScript.write("else\n")
+        buildScript.write(">&2 echo \"Action did not compile\"\n")
+        buildScript.write("exit 1\n")
+        buildScript.write("fi")
+
+    os.chmod(GENERATED_BUILD_SCRIPT, 0o777)
+    sys.exit(0)
+else:
+    print("Cannot generate build script: compile or link command not found")
+    sys.exit(1)
diff --git a/swift-playground-action/swift3Action/delete-build-run.sh b/swift-playground-action/swift3Action/delete-build-run.sh
new file mode 100755
index 0000000..430c02d
--- /dev/null
+++ b/swift-playground-action/swift3Action/delete-build-run.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# Useful for local testing.
+# USE WITH CAUTION !!
+
+# This script is useful for testing the action proxy (or its derivatives)
+# in combination with [init,run].py. Use it to rebuild the container image
+# and start the proxy: delete-build-run.sh whisk/dockerskeleton.
+
+# Removes all previously built instances.
+remove=$(docker ps -a -q)
+if [[ !  -z  $remove  ]]; then
+    docker rm $remove
+fi
+
+image=${1:-openwhisk/dockerskeleton}
+docker build -t $image .
+
+echo ""
+echo "  ---- RUNNING ---- "
+echo ""
+
+docker run -i -t -p 8080:8080 $image
diff --git a/swift-playground-action/swift3Action/epilogue.swift b/swift-playground-action/swift3Action/epilogue.swift
new file mode 100644
index 0000000..9107234
--- /dev/null
+++ b/swift-playground-action/swift3Action/epilogue.swift
@@ -0,0 +1,78 @@
+
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Deliberate whitespaces above.
+
+/* This code is appended to user-supplied action code.
+ It reads from the standard input, deserializes into JSON and invokes the
+ main function. Currently, actions print strings to stdout. This can evolve once
+ JSON serialization is available in Foundation. */
+
+import Foundation
+
+#if os(Linux)
+    import Glibc
+#endif
+
+func _whisk_json2dict(txt: String) -> [String:Any]? {
+    if let data = txt.data(using: String.Encoding.utf8, allowLossyConversion: true) {
+        do {
+            return WhiskJsonUtils.jsonDataToDictionary(jsonData: data)
+        } catch {
+            return nil
+        }
+    }
+    return nil
+}
+
+
+func _run_main(mainFunction: ([String: Any]) -> [String: Any]) -> Void {
+    let env = ProcessInfo.processInfo.environment
+    let inputStr: String = env["WHISK_INPUT"] ?? "{}"
+    
+    if let parsed = _whisk_json2dict(txt: inputStr) {
+        let result = mainFunction(parsed)
+        
+        if result is [String:Any] {
+            do {
+                if let respString = WhiskJsonUtils.dictionaryToJsonString(jsonDict: result) {
+                    print("\(respString)")
+                } else {
+                    print("Error converting \(result) to JSON string")
+                    #if os(Linux)
+                        fputs("Error converting \(result) to JSON string", stderr)
+                    #endif
+                }
+            } catch {
+                print("Error serializing response \(error)")
+                #if os(Linux)
+                    fputs("Error serializing response \(error)", stderr)
+                #endif
+            }
+        } else {
+            print("Cannot serialize response: \(result)")
+            #if os(Linux)
+                fputs("Cannot serialize response: \(result)", stderr)
+            #endif
+        }
+    } else {
+        print("Error: couldn't parse JSON input.")
+        #if os(Linux)
+            fputs("Error: couldn't parse JSON input.", stderr)
+        #endif
+    }
+}
diff --git a/swift-playground-action/swift3Action/invoke.py b/swift-playground-action/swift3Action/invoke.py
new file mode 100755
index 0000000..92d8a6d
--- /dev/null
+++ b/swift-playground-action/swift3Action/invoke.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+"""Executable Python script for testing the action proxy.
+
+  This script is useful for testing the action proxy (or its derivatives)
+  by simulating invoker interactions. Use it in combination with
+  delete-build-run.sh which builds and starts up the action proxy.
+  Examples:
+     ./delete-build-run.sh &
+     ./invoke.py init <action source file> # should return OK
+     ./invoke.py run '{"some":"json object as a string"}'
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"""
+
+import os
+import re
+import sys
+import json
+import requests
+import codecs
+
+DOCKER_HOST = "localhost"
+if "DOCKER_HOST" in os.environ:
+    try:
+        DOCKER_HOST = re.compile("tcp://(.*):[\d]+").findall(
+            os.environ["DOCKER_HOST"])[0]
+    except Exception:
+        print("cannot determine docker host from %s" %
+              os.environ["DOCKER_HOST"])
+        sys.exit(-1)
+DEST = "http://%s:8080" % DOCKER_HOST
+
+
+def content_from_args(args):
+    if len(args) == 0:
+        return None
+
+    if len(args) == 1 and os.path.exists(args[0]):
+        with open(args[0]) as fp:
+            return json.load(fp)
+
+    # else...
+    in_str = " ".join(args)
+    try:
+        d = json.loads(in_str)
+        if isinstance(d, dict):
+            return d
+        else:
+            raise "Not a dict."
+    except:
+        return in_str
+
+
+def init(args):
+    main = args[1] if len(args) == 2 else "main"
+    args = args[0] if len(args) >= 1 else None
+
+    if args and args.endswith(".zip"):
+        with open(args, "rb") as fp:
+            contents = fp.read().encode("base64")
+        binary = True
+    elif args:
+        with(codecs.open(args, "r", "utf-8")) as fp:
+            contents = fp.read()
+        binary = False
+    else:
+        contents = None
+        binary = False
+
+    r = requests.post("%s/init" % DEST, json={"value": {"code": contents,
+                                                        "binary": binary,
+                                                        "main": main}})
+    print(r.text)
+
+
+def run(args):
+    value = content_from_args(args)
+    # print("Sending value: %s..." % json.dumps(value)[0:40])
+    r = requests.post("%s/run" % DEST, json={"value": value})
+    print(r.text)
+
+
+if sys.argv[1] == "init":
+    init(sys.argv[2:])
+elif sys.argv[1] == "run":
+    run(sys.argv[2:])
+else:
+    print("usage: 'init <filename>' or 'run JSON-as-string'")
diff --git a/swift-playground-action/swift3Action/spm-build/Package.swift b/swift-playground-action/swift3Action/spm-build/Package.swift
new file mode 100644
index 0000000..c4b964d
--- /dev/null
+++ b/swift-playground-action/swift3Action/spm-build/Package.swift
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import PackageDescription
+
+let package = Package(
+    name: "Action",
+        dependencies: [
+    .Package(url: "https://github.com/IBM-Swift/Kitura-net.git", "1.0.1"),
+            .Package(url: "https://github.com/IBM-Swift/SwiftyJSON.git", "14.2.0"),
+            .Package(url: "https://github.com/IBM-Swift/swift-watson-sdk.git", "0.4.1")
+        ]
+)
diff --git a/swift-playground-action/swift3Action/spm-build/_Whisk.swift b/swift-playground-action/swift3Action/spm-build/_Whisk.swift
new file mode 100644
index 0000000..d1124ed
--- /dev/null
+++ b/swift-playground-action/swift3Action/spm-build/_Whisk.swift
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import KituraNet
+import Dispatch
+
+class Whisk {
+    class func invoke(actionNamed action : String, withParameters params : [String:Any], blocking: Bool = true) -> [String:Any] {
+        let parsedAction = parseQualifiedName(name: action)
+        let strBlocking = blocking ? "true" : "false"
+        let path = "/api/v1/namespaces/\(parsedAction.namespace)/actions/\(parsedAction.name)?blocking=\(strBlocking)"
+
+        return postSyncronish(uriPath: path, params: params)
+    }
+
+    class func trigger(eventNamed event : String, withParameters params : [String:Any]) -> [String:Any] {
+        let parsedEvent = parseQualifiedName(name: event)
+        let path = "/api/v1/namespaces/\(parsedEvent.namespace)/triggers/\(parsedEvent.name)?blocking=true"
+
+        return postSyncronish(uriPath: path, params: params)
+    }
+
+    // handle the GCD dance to make the post async, but then obtain/return
+    // the result from this function sync
+    private class func postSyncronish(uriPath path: String, params : [String:Any]) -> [String:Any] {
+        var response : [String:Any]!
+
+        let queue = DispatchQueue.global()
+        let invokeGroup = DispatchGroup()
+
+        invokeGroup.enter()
+        queue.async {
+            post(uriPath: path, params: params, group: invokeGroup) { result in
+                response = result
+            }
+        }
+
+        // On one hand, FOREVER seems like an awfully long time...
+        // But on the other hand, I think we can rely on the system to kill this
+        // if it exceeds a reasonable execution time.
+        switch invokeGroup.wait(timeout: DispatchTime.distantFuture) {
+        case DispatchTimeoutResult.success:
+            break
+        case DispatchTimeoutResult.timedOut:
+            break
+        }
+
+        return response
+    }
+
+    /**
+     * Initializes with host, port and authKey determined from environment variables
+     * __OW_API_HOST and __OW_API_KEY, respectively.
+     */
+    private class func initializeCommunication() -> (httpType: String, host : String, port : Int16, authKey : String) {
+        let env = ProcessInfo.processInfo.environment
+
+        var edgeHost : String!
+        if let edgeHostEnv : String = env["__OW_API_HOST"] {
+            edgeHost = "\(edgeHostEnv)"
+        } else {
+            fatalError("__OW_API_HOST environment variable was not set.")
+        }
+
+        var protocolIndex = edgeHost.startIndex
+
+        //default to https
+        var httpType = "https://"
+        var port : Int16 = 443
+
+        // check if protocol is included in environment variable
+        if edgeHost.hasPrefix("https://") {
+            protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 8)
+        } else if edgeHost.hasPrefix("http://") {
+            protocolIndex = edgeHost.index(edgeHost.startIndex, offsetBy: 7)
+            httpType = "http://"
+            port = 80
+        }
+
+        let hostname = edgeHost.substring(from: protocolIndex)
+        let hostComponents = hostname.components(separatedBy: ":")
+
+        let host = hostComponents[0]
+
+        if hostComponents.count == 2 {
+            port = Int16(hostComponents[1])!
+        }
+
+        var authKey = "authKey"
+        if let authKeyEnv : String = env["__OW_API_KEY"] {
+            authKey = authKeyEnv
+        }
+
+        return (httpType, host, port, authKey)
+    }
+
+    // actually do the POST call to the specified OpenWhisk URI path
+    private class func post(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
+        let communicationDetails = initializeCommunication()
+
+        let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
+        let base64EncodedAuthKey  = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
+
+        let headers = ["Content-Type" : "application/json",
+                       "Authorization" : "Basic \(base64EncodedAuthKey)"]
+
+        guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
+            callback(["error": "Error encoding uri path to make openwhisk REST call."])
+            return
+        }
+
+        // TODO vary the schema based on the port?
+        let requestOptions = [ClientRequest.Options.schema(communicationDetails.httpType),
+                              ClientRequest.Options.method("post"),
+                              ClientRequest.Options.hostname(communicationDetails.host),
+                              ClientRequest.Options.port(communicationDetails.port),
+                              ClientRequest.Options.path(encodedPath),
+                              ClientRequest.Options.headers(headers),
+                              ClientRequest.Options.disableSSLVerification]
+
+        let request = HTTP.request(requestOptions) { response in
+
+            // exit group after we are done
+            defer {
+                group.leave()
+            }
+
+            if response != nil {
+                do {
+                    // this is odd, but that's just how KituraNet has you get
+                    // the response as NSData
+                    var jsonData = Data()
+                    try response!.readAllData(into: &jsonData)
+
+                    switch WhiskJsonUtils.getJsonType(jsonData: jsonData) {
+                    case .Dictionary:
+                        if let resp = WhiskJsonUtils.jsonDataToDictionary(jsonData: jsonData) {
+                            callback(resp)
+                        } else {
+                            callback(["error": "Could not parse a valid JSON response."])
+                        }
+                    case .Array:
+                        if WhiskJsonUtils.jsonDataToArray(jsonData: jsonData) != nil {
+                            callback(["error": "Response is an array, expecting dictionary."])
+                        } else {
+                            callback(["error": "Could not parse a valid JSON response."])
+                        }
+                    case .Undefined:
+                        callback(["error": "Could not parse a valid JSON response."])
+                    }
+
+                } catch {
+                    callback(["error": "Could not parse a valid JSON response."])
+                }
+            } else {
+                callback(["error": "Did not receive a response."])
+            }
+        }
+
+        // turn params into JSON data
+        if let jsonData = WhiskJsonUtils.dictionaryToJsonString(jsonDict: params) {
+            request.write(from: jsonData)
+            request.end()
+        } else {
+            callback(["error": "Could not parse parameters."])
+            group.leave()
+        }
+
+    }
+
+    /**
+     * This function is currently unused but ready when we want to switch to using URLSession instead of KituraNet.
+     */
+    private class func postUrlSession(uriPath: String, params : [String:Any], group: DispatchGroup, callback : @escaping([String:Any]) -> Void) {
+        let communicationDetails = initializeCommunication()
+
+        guard let encodedPath = uriPath.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) else {
+            callback(["error": "Error encoding uri path to make openwhisk REST call."])
+            return
+        }
+
+        let urlStr = "\(communicationDetails.httpType)\(communicationDetails.host):\(communicationDetails.port)\(encodedPath)"
+
+        if let url = URL(string: urlStr) {
+            var request = URLRequest(url: url)
+            request.httpMethod = "POST"
+
+            do {
+                request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+                request.httpBody = try JSONSerialization.data(withJSONObject: params)
+
+                let loginData: Data = communicationDetails.authKey.data(using: String.Encoding.utf8, allowLossyConversion: false)!
+                let base64EncodedAuthKey  = loginData.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
+                request.addValue("Basic \(base64EncodedAuthKey)", forHTTPHeaderField: "Authorization")
+
+                let session = URLSession(configuration: URLSessionConfiguration.default)
+
+                let task = session.dataTask(with: request, completionHandler: {data, response, error -> Void in
+
+                    // exit group after we are done
+                    defer {
+                        group.leave()
+                    }
+
+                    if let error = error {
+                        callback(["error":error.localizedDescription])
+                    } else {
+
+                        if let data = data {
+                            do {
+                                let respJson = try JSONSerialization.jsonObject(with: data)
+                                if respJson is [String:Any] {
+                                    callback(respJson as! [String:Any])
+                                } else {
+                                    callback(["error":" response from server is not a dictionary"])
+                                }
+                            } catch {
+                                callback(["error":"Error creating json from response: \(error)"])
+                            }
+                        }
+                    }
+                })
+
+                task.resume()
+            } catch {
+                callback(["error":"Got error creating params body: \(error)"])
+            }
+        }
+    }
+
+    // separate an OpenWhisk qualified name (e.g. "/whisk.system/samples/date")
+    // into namespace and name components
+    private class func parseQualifiedName(name qualifiedName : String) -> (namespace : String, name : String) {
+        let defaultNamespace = "_"
+        let delimiter = "/"
+
+        let segments :[String] = qualifiedName.components(separatedBy: delimiter)
+
+        if segments.count > 2 {
+            return (segments[1], Array(segments[2..<segments.count]).joined(separator: delimiter))
+        } else {
+            // allow both "/theName" and "theName"
+            let name = qualifiedName.hasPrefix(delimiter) ? segments[1] : segments[0]
+            return (defaultNamespace, name)
+        }
+    }
+}
diff --git a/swift-playground-action/swift3Action/spm-build/_WhiskJSONUtils.swift b/swift-playground-action/swift3Action/spm-build/_WhiskJSONUtils.swift
new file mode 100644
index 0000000..f9e6460
--- /dev/null
+++ b/swift-playground-action/swift3Action/spm-build/_WhiskJSONUtils.swift
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import SwiftyJSON
+
+enum WhiskJsonType {
+    case Dictionary
+    case Array
+    case Undefined
+}
+
+class WhiskJsonUtils {
+
+    class func getJsonType(jsonData: Data) -> WhiskJsonType {
+        do {
+            let json = try JSONSerialization.jsonObject(with: jsonData, options: [])
+            if json is [String:Any] {
+                return .Dictionary
+            } else if json is [Any] {
+                return .Array
+            } else {
+                return .Undefined
+            }
+        } catch {
+            print("Error converting JSON data to dictionary \(error)")
+            return .Undefined
+        }
+    }
+
+    class func jsonDataToArray(jsonData: Data) -> [Any]? {
+        do {
+            let arr = try JSONSerialization.jsonObject(with: jsonData, options: [])
+            return (arr as? [Any])
+        } catch {
+            print("Error converting JSON data to dictionary \(error)")
+            return nil
+        }
+    }
+
+    class func jsonDataToDictionary(jsonData: Data) -> [String:Any]? {
+        do {
+            let dic = try JSONSerialization.jsonObject(with: jsonData, options: [])
+            return dic as? [String:Any]
+        } catch {
+            print("Error converting JSON data to dictionary \(error)")
+            return nil
+        }
+    }
+
+    // use SwiftyJSON to serialize JSON object because of bug in Linux Swift 3.0
+    // https://github.com/IBM-Swift/SwiftRuntime/issues/230
+    class func dictionaryToJsonString(jsonDict: [String:Any]) -> String? {
+        if JSONSerialization.isValidJSONObject(jsonDict) {
+            do {
+                let jsonData = try JSONSerialization.data(withJSONObject: jsonDict, options: [])
+                if let jsonStr = String(data: jsonData, encoding: String.Encoding.utf8) {
+                    return jsonStr
+                } else {
+                    print("Error serializing data to JSON, data conversion returns nil string")
+                }
+            } catch {
+                print(("\(error)"))
+            }
+        } else {
+            print("Error serializing JSON, data does not appear to be valid JSON")
+        }
+        return nil
+    }
+
+    class func dictionaryToData(jsonDict: [String:Any]) -> Data? {
+        let json: JSON = JSON(jsonDict)
+
+        do {
+            let data: Data = try json.rawData()
+            return data
+        } catch {
+            print("Cannot convert Dictionary to Data")
+            return nil
+        }
+    }
+
+    class func arrayToJsonString(jsonArray: [Any]) -> String? {
+        let json: JSON = JSON(jsonArray)
+
+        if let jsonStr = json.rawString() {
+            let trimmed = jsonStr.replacingOccurrences(of: "\n", with: "").replacingOccurrences(of: "\r", with: "")
+            return trimmed
+        } else {
+            return nil
+        }
+    }
+
+    class func arrayToData(jsonArray: [Any]) -> Data? {
+        let json: JSON = JSON(jsonArray)
+
+        do {
+            let data: Data = try json.rawData()
+            return data
+        } catch {
+            print("Cannot convert Array to Data")
+            return nil
+        }
+    }
+
+    private class func escapeDict(json: [String:Any]) -> [String:Any] {
+        var escaped = [String:Any]()
+
+        for (k,v) in json {
+            if v is String {
+                let str = (v as! String).replacingOccurrences(of:"\"", with:"\\\"")
+                escaped[k] = str
+            } else if v is [String:Any] {
+                escaped[k] = escapeDict(json: v as! [String : Any])
+            } else if v is [Any] {
+                escaped[k] = escapeArray(json: v as! [Any])
+            } else {
+                escaped[k] = v
+            }
+        }
+        return escaped
+    }
+
+    private class func escapeArray(json: [Any]) -> [Any] {
+        var escaped = [Any]()
+
+        for v in json {
+            if v is String {
+                let str = (v as! String).replacingOccurrences(of:"\"", with:"\\\"")
+                escaped.append(str)
+            } else if v is [String:Any] {
+                let dic = escapeDict(json: v as! [String:Any])
+                escaped.append(dic)
+            } else if v is [Any] {
+                let arr = escapeArray(json: v as! [Any])
+                escaped.append(arr)
+            } else {
+                escaped.append(v)
+            }
+        }
+
+        return escaped
+    }
+
+    private class func escape(json: Any) -> Any? {
+        if json is [String:Any] {
+            let escapeObj = json as! [String:Any]
+            return escapeDict(json: escapeObj)
+        } else if json is [Any] {
+            let escapeObj = json as! [Any]
+            return escapeArray(json: escapeObj)
+        } else {
+            return nil
+        }
+    }
+}
diff --git a/swift-playground-action/swift3Action/stub.sh b/swift-playground-action/swift3Action/stub.sh
new file mode 100644
index 0000000..842d00a
--- /dev/null
+++ b/swift-playground-action/swift3Action/stub.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+echo \
+'This is a stub action that should be replaced with user code (e.g., script or compatible binary).
+The input to the action is received as an argument from the command line.
+Actions may log to stdout or stderr. By convention, the last line of output must
+be a stringified JSON object which represents the result of the action.'
+
+echo '{ "error": "This is a stub action. Replace it with custom logic." }'
\ No newline at end of file
diff --git a/swift-playground-action/swift3Action/swift3runner.py b/swift-playground-action/swift3Action/swift3runner.py
new file mode 100644
index 0000000..f41456d
--- /dev/null
+++ b/swift-playground-action/swift3Action/swift3runner.py
@@ -0,0 +1,114 @@
+"""Python proxy to run Swift action.
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"""
+import os
+import glob
+import sys
+import subprocess
+import codecs
+import json
+sys.path.append('../actionProxy')
+from actionproxy import ActionRunner, main, setRunner  # noqa
+
+SRC_EPILOGUE_FILE = '/swift3Action/epilogue.swift'
+DEST_SCRIPT_FILE = '/swift3Action/spm-build/main.swift'
+DEST_SCRIPT_DIR = '/swift3Action/spm-build'
+DEST_BIN_FILE = '/swift3Action/spm-build/.build/release/Action'
+
+BUILD_PROCESS = ['./swiftbuildandlink.sh']
+
+
+class Swift3Runner(ActionRunner):
+
+    def __init__(self):
+        ActionRunner.__init__(self, DEST_SCRIPT_FILE, DEST_BIN_FILE)
+
+    # remove pre-existing binary before receiving a new binary
+    def preinit(self):
+        try:
+            os.remove(self.binary)
+        except: pass
+
+    def epilogue(self, init_message):
+        # skip if executable already exists (was unzipped)
+        if os.path.isfile(self.binary):
+            return
+
+        if 'main' in init_message:
+            main_function = init_message['main']
+        else:
+            main_function = 'main'
+        # make sure there is a main.swift file
+        open(DEST_SCRIPT_FILE, 'a').close()
+
+        with codecs.open(DEST_SCRIPT_FILE, 'a', 'utf-8') as fp:
+            os.chdir(DEST_SCRIPT_DIR)
+            for file in glob.glob("*.swift"):
+                if file not in ["Package.swift", "main.swift", "_WhiskJSONUtils.swift", "_Whisk.swift"]:
+                    with codecs.open(file, 'r', 'utf-8') as f:
+                        fp.write(f.read())
+            with codecs.open(SRC_EPILOGUE_FILE, 'r', 'utf-8') as ep:
+                fp.write(ep.read())
+
+            fp.write('_run_main(mainFunction: %s)\n' % main_function)
+
+    def build(self, init_message):
+        # short circuit the build, if there already exists a binary
+        # from the zip file
+        if os.path.isfile(self.binary):
+            # file may not have executable permission, set it
+            os.chmod(self.binary, 0o555)
+            return
+
+        p = subprocess.Popen(
+            BUILD_PROCESS,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=DEST_SCRIPT_DIR)
+
+        # run the process and wait until it completes.
+        # stdout/stderr will not be None because we passed PIPEs to Popen
+        (o, e) = p.communicate()
+
+        # stdout/stderr may be either text or bytes, depending on Python
+        # version, so if bytes, decode to text. Note that in Python 2
+        # a string will match both types; so also skip decoding in that case
+        if isinstance(o, bytes) and not isinstance(o, str):
+            o = o.decode('utf-8')
+        if isinstance(e, bytes) and not isinstance(e, str):
+            e = e.decode('utf-8')
+
+        if o:
+            sys.stdout.write(o)
+            sys.stdout.flush()
+
+        if e:
+            sys.stderr.write(e)
+            sys.stderr.flush()
+
+    def env(self, message):
+        env = ActionRunner.env(self, message)
+        args = message.get('value', {}) if message else {}
+        env['WHISK_INPUT'] = json.dumps(args)
+        return env
+
+
+if __name__ == '__main__':
+    setRunner(Swift3Runner())
+    main()
diff --git a/swift-playground-action/test0.swift b/swift-playground-action/test0.swift
new file mode 100644
index 0000000..1c6ee55
--- /dev/null
+++ b/swift-playground-action/test0.swift
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+print("Hello World");
diff --git a/swift-playground-action/test1.swift b/swift-playground-action/test1.swift
new file mode 100644
index 0000000..8dc17c7
--- /dev/null
+++ b/swift-playground-action/test1.swift
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//import Dispatch
+import Foundation
+import SwiftyJSON
+
+//let json: JSON = "I'm a json"
+let json = JSON(["name":"Joe Doe", "age": 25])
+if let name = json["name"].string {
+   print("Hello", name);
+}
diff --git a/swift-playground-action/test2.swift b/swift-playground-action/test2.swift
new file mode 100644
index 0000000..15df760
--- /dev/null
+++ b/swift-playground-action/test2.swift
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//import Dispatch
+import Foundation
+import SwiftyJSON
+import KituraNet
+import Dispatch
+import SSLService
+
+//let json: JSON = "I'm a json"
+// let json = JSON(["name":"Paul", "age": 25])
+// if let name = json["name"].string {
+//    print("Hello ", name);
+// }
diff --git a/swift-playground-action/test3.swift b/swift-playground-action/test3.swift
new file mode 100644
index 0000000..97c0e1e
--- /dev/null
+++ b/swift-playground-action/test3.swift
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//import Dispatch
+import Foundation
+import SwiftyJSON
+import Conversation
+import RestKit
+
+//let json: JSON = "I'm a json"
+// let json = JSON(["name":"Paul", "age": 25])
+// if let name = json["name"].string {
+//    print("Hello ", name);
+// }
+
+let username = "aa50bee6-a71b-47d3-8dca-e23b628315e3"
+let password = "mtqVUlA5WCZy"
+let version = "2016-07-19" // use today's date for the most recent version
+let conversation = Conversation(username: username, password: password, version: version)
+
+let workspaceID = "b4ff2246-c42f-407e-b172-72a631cf5498"
+let failure = { (error: RestError) in print("error", error) }
+var context: Context? // save context to continue conversation
+var text = "hello"
+conversation.message(workspaceID: workspaceID, text: text, failure: failure) { response in
+    //print(response.output.text)
+    print("response",response)
+    context = response.context
+}
+
+// conversation.message(workspaceID: workspaceID, text: text, context: context, failure: failure) { response in
+//     print(response.output.text)
+//     context = response.context
+// }
diff --git a/swift-playground-action/test4.swift b/swift-playground-action/test4.swift
new file mode 100644
index 0000000..ea3ff8a
--- /dev/null
+++ b/swift-playground-action/test4.swift
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2015-2016 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//import Dispatch
+import Foundation
+import SwiftyJSON
+import Conversation
+import RestKit
+
+//var serviceURL = "https://jsonplaceholder.typicode.com"
+
+let username = "aa50bee6-a71b-47d3-8dca-e23b628315e3"
+let password = "mtqVUlA5WCZy"
+let version = "2016-07-19" 
+
+var serviceURL = "https://gateway.watsonplatform.net/conversation/api"
+
+var queryParameters = [URLQueryItem]()
+queryParameters.append(URLQueryItem(name: "version", value: version))
+
+let request = RestRequest(
+        method: .GET,
+        url: serviceURL + "/v1/workspaces",
+        acceptType: "application/json",
+        contentType: "application/json",
+        queryParameters: queryParameters,
+        username: username,
+        password: password         
+    )
+
+let failure = { (error: RestError) in print("error", error) }
+
+let success = { (msg) in print("success", msg) }
+
+// execute REST request
+request.responseJSON { response in
+    switch response {
+    case .success(let json): success(json)
+    case .failure(let error): failure(error)
+    }
+}