diff --git a/Pipfile b/PythonBridgeRuntime/Pipfile
similarity index 100%
rename from Pipfile
rename to PythonBridgeRuntime/Pipfile
diff --git a/__init__.py b/PythonBridgeRuntime/PythonBridge/__init__.py
similarity index 100%
rename from __init__.py
rename to PythonBridgeRuntime/PythonBridge/__init__.py
diff --git a/bridge_globals.py b/PythonBridgeRuntime/PythonBridge/bridge_globals.py
similarity index 100%
rename from bridge_globals.py
rename to PythonBridgeRuntime/PythonBridge/bridge_globals.py
diff --git a/bridge_hooks.py b/PythonBridgeRuntime/PythonBridge/bridge_hooks.py
similarity index 100%
rename from bridge_hooks.py
rename to PythonBridgeRuntime/PythonBridge/bridge_hooks.py
diff --git a/bridge_utils.py b/PythonBridgeRuntime/PythonBridge/bridge_utils.py
similarity index 100%
rename from bridge_utils.py
rename to PythonBridgeRuntime/PythonBridge/bridge_utils.py
diff --git a/flask_platform.py b/PythonBridgeRuntime/PythonBridge/flask_platform.py
similarity index 100%
rename from flask_platform.py
rename to PythonBridgeRuntime/PythonBridge/flask_platform.py
diff --git a/json_encoder.py b/PythonBridgeRuntime/PythonBridge/json_encoder.py
similarity index 100%
rename from json_encoder.py
rename to PythonBridgeRuntime/PythonBridge/json_encoder.py
diff --git a/msgpack_serializer.py b/PythonBridgeRuntime/PythonBridge/msgpack_serializer.py
similarity index 100%
rename from msgpack_serializer.py
rename to PythonBridgeRuntime/PythonBridge/msgpack_serializer.py
diff --git a/msgpack_socket_platform.py b/PythonBridgeRuntime/PythonBridge/msgpack_socket_platform.py
similarity index 100%
rename from msgpack_socket_platform.py
rename to PythonBridgeRuntime/PythonBridge/msgpack_socket_platform.py
diff --git a/object_registry.py b/PythonBridgeRuntime/PythonBridge/object_registry.py
similarity index 100%
rename from object_registry.py
rename to PythonBridgeRuntime/PythonBridge/object_registry.py
diff --git a/python_bridge.py b/PythonBridgeRuntime/PythonBridge/python_bridge.py
similarity index 95%
rename from python_bridge.py
rename to PythonBridgeRuntime/PythonBridge/python_bridge.py
index e9b1847..2ed7d8e 100644
--- a/python_bridge.py
+++ b/PythonBridgeRuntime/PythonBridge/python_bridge.py
@@ -5,6 +5,12 @@
 from PythonBridge.bridge_hooks import *
 from PythonBridge.object_registry import registry
 
+def pbbreak():
+        print("Breaking now")
+        breakpoint()
+        print("Continuing")
+
+
 class EvalCommand:
 	statements = ""
 	binding = {}
@@ -158,4 +164,4 @@ def run_bridge():
 		bridge_globals.logger.log("PYTHON: Finished command execution")
 
 if __name__ == "__main__":
-	run_bridge()
\ No newline at end of file
+	run_bridge()
diff --git a/stoppable_thread.py b/PythonBridgeRuntime/PythonBridge/stoppable_thread.py
similarity index 100%
rename from stoppable_thread.py
rename to PythonBridgeRuntime/PythonBridge/stoppable_thread.py
diff --git a/PythonBridgeRuntime/PythonBridge/tfactorial.py b/PythonBridgeRuntime/PythonBridge/tfactorial.py
new file mode 100644
index 0000000..01c8f01
--- /dev/null
+++ b/PythonBridgeRuntime/PythonBridge/tfactorial.py
@@ -0,0 +1,36 @@
+import argparse
+import threading
+import time
+
+
+# Calculate the factorial
+def factorial(n, t):
+    time.sleep(n*t/4)
+    print("Start: " + str(t) + ": " + str(n))
+    if n == 1:
+        res = 1
+        if t == 1:
+            print("Feel free to break here")
+    else:
+        res = n * factorial(n-1, t)
+    return res
+
+
+# Calculate the factorial and print the result
+def factorial_thread(n, t):
+    time.sleep(2)
+    result = factorial(n, t)
+    print("Thread " + str(t) + " = "+str(result))
+
+
+def launch_factorials(n):
+    threads = []
+    print("Calculate: "+str(n))
+    breakpoint()
+    for i in range(n):
+        threads.append(threading.Thread(target=factorial_thread, args=(n+i, i+1)))
+        threads[-1].start()
+    print("Wait for the results")
+    for thread in threads:
+        thread.join()
+    print("Done")
diff --git a/tmp.py b/PythonBridgeRuntime/PythonBridge/tmp.py
similarity index 100%
rename from tmp.py
rename to PythonBridgeRuntime/PythonBridge/tmp.py
diff --git a/install_env.sh b/PythonBridgeRuntime/install_env.sh
similarity index 58%
rename from install_env.sh
rename to PythonBridgeRuntime/install_env.sh
index c5928ac..f05c06a 100755
--- a/install_env.sh
+++ b/PythonBridgeRuntime/install_env.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
 cd "$(dirname "$0")"
 export PIPENV_VENV_IN_PROJECT=1
-pipenv install
\ No newline at end of file
+pipenv install
+pipenv run pip install debugpy
diff --git a/PythonBridgeRuntime/killpbservers.sh b/PythonBridgeRuntime/killpbservers.sh
new file mode 100755
index 0000000..a6c900d
--- /dev/null
+++ b/PythonBridgeRuntime/killpbservers.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Kill all the PythonBridge servers running on localhost.
+# This assumes they are being run as the current user.
+# Any associated debug server processes will automatically exit.
+
+# List the processes.
+# If none are found, exit successfully
+ps aux | grep -E 'PythonBridgeRuntime/start_bridge\.py.*msgpack'
+status=$?
+if [ $status -eq 1 ]
+then
+	exit 0
+fi
+
+# Kill them
+ps aux | grep -E 'PythonBridgeRuntime/start_bridge\.py.*msgpack' | awk '{print $2}' | xargs kill
+exit $?
diff --git a/run_command.bat b/PythonBridgeRuntime/run_command.bat
similarity index 100%
rename from run_command.bat
rename to PythonBridgeRuntime/run_command.bat
diff --git a/start_bridge.py b/PythonBridgeRuntime/start_bridge.py
similarity index 100%
rename from start_bridge.py
rename to PythonBridgeRuntime/start_bridge.py
diff --git a/windows_install_env.bat b/PythonBridgeRuntime/windows_install_env.bat
similarity index 100%
rename from windows_install_env.bat
rename to PythonBridgeRuntime/windows_install_env.bat
diff --git a/src/BaselineOfPythonBridge/BaselineOfPythonBridge.class.st b/src/BaselineOfPythonBridge/BaselineOfPythonBridge.class.st
index d7b02ea..fa9e2a9 100644
--- a/src/BaselineOfPythonBridge/BaselineOfPythonBridge.class.st
+++ b/src/BaselineOfPythonBridge/BaselineOfPythonBridge.class.st
@@ -12,13 +12,13 @@ BaselineOfPythonBridge >> baseline: spec [
 		do: [			
 			spec
 				baseline: 'OSSubprocess' 
-				with: [ spec repository: 'github://pharo-contributions/OSSubprocess:v1.0.0/repository' ].
+				with: [ spec repository: 'github://feenkcom/OSSubprocess:main/repository' ].
 			spec
 				baseline: 'Python3Generator' 
 				with: [ spec repository: 'github://juliendelplanque/Python3Generator:v2.0.0/repository' ].
 			spec baseline: 'NeoJSON' with: [
                 spec
-                    repository: 'github://svenvc/NeoJSON/repository' ].
+                    repository: 'github://svenvc/NeoJSON:v17/repository' ].
 			spec baseline: 'MessagePack' with: [
                 spec
                     repository: 'github://msgpack/msgpack-smalltalk:v1.3.1/repository' ].
diff --git a/src/PythonBridge-Pharo/PBMsgPackPharoBrokerTest.class.st b/src/PythonBridge-Pharo/PBMsgPackPharoBrokerTest.class.st
index aa047ee..5da3bd9 100644
--- a/src/PythonBridge-Pharo/PBMsgPackPharoBrokerTest.class.st
+++ b/src/PythonBridge-Pharo/PBMsgPackPharoBrokerTest.class.st
@@ -60,6 +60,17 @@ PBMsgPackPharoBrokerTest >> sendMessageToBroker: dict answerBlock: aBlock [
 	self sleepAWhile.
 ]
 
+{ #category : #utils }
+PBMsgPackPharoBrokerTest >> sendMessageToBroker: dict answerEquals: ansDict [
+	| flag |
+	flag := false.
+	self sendMessageToBroker: dict answerBlock: [ :anAssoc |
+		flag := true.
+		self assert: anAssoc value equals: ansDict ].
+	self sleepAWhile.
+	self assert: flag
+]
+
 { #category : #utils }
 PBMsgPackPharoBrokerTest >> sleepAWhile [
 	(Delay forMilliseconds: 50) wait
diff --git a/src/PythonBridge-Pharo/PBPharoPipenvProcess.class.st b/src/PythonBridge-Pharo/PBPharoPipenvProcess.class.st
index c4cfe73..644ef87 100644
--- a/src/PythonBridge-Pharo/PBPharoPipenvProcess.class.st
+++ b/src/PythonBridge-Pharo/PBPharoPipenvProcess.class.st
@@ -3,7 +3,8 @@ Class {
 	#superclass : #PBAbstractProcess,
 	#instVars : [
 		'process',
-		'environmentVariables'
+		'environmentVariables',
+		'serverDebugger'
 	],
 	#classVars : [
 		'PipenvPath'
@@ -11,16 +12,22 @@ Class {
 	#category : #'PythonBridge-Pharo-Processes'
 }
 
+{ #category : #'class initialization' }
+PBPharoPipenvProcess class >> initialize [ 
+
+	SessionManager default registerUserClassNamed: self name.
+]
+
 { #category : #initialization }
 PBPharoPipenvProcess class >> pipenvPath [
-	^ PipenvPath isEmptyOrNil 
-			ifTrue: [ PipenvPath := self resolvePipenvPath ]
-			ifFalse: [ PipenvPath ]
+	^ PipenvPath 
+			ifNil: [ PipenvPath := self resolvePipenvPath ]
+			ifNotNil: [ PipenvPath ]
 ]
 
 { #category : #initialization }
-PBPharoPipenvProcess class >> pipenvPath: aString [
-	PipenvPath := aString
+PBPharoPipenvProcess class >> pipenvPath: aFileReference [
+	PipenvPath := aFileReference
 ]
 
 { #category : #accessing }
@@ -28,16 +35,26 @@ PBPharoPipenvProcess class >> platform [
 	^ PBPharoPlatform current
 ]
 
+{ #category : #initialization }
+PBPharoPipenvProcess class >> reset [ 
+	<script>
+
+	PipenvPath := nil.
+]
+
 { #category : #initialization }
 PBPharoPipenvProcess class >> resolvePipenvPath [
-	^ (OSSUnixSubprocess new
+	| path |
+
+	(OSSUnixSubprocess new
 				command: '/usr/bin/which';
 				arguments: (Array with: 'pipenv');
 				addAllEnvVariablesFromParentWithoutOverride;
 				redirectStdout;
 				terminateOnShutdown;
-				runAndWaitOnExitDo: [ :command :outString | ^ outString trim ]) 
-					ifEmpty: [ self signalPipenvNotFound ]
+				runAndWaitOnExitDo: [ :command :outString | path := outString trim ]).
+	path ifEmpty: [ self signalPipenvNotFound ].
+	^ path asFileReference
 ]
 
 { #category : #initialization }
@@ -55,6 +72,23 @@ PBPharoPipenvProcess class >> signalPipenvNotFound [
 	Error signal: 'Error: Pipenv command could not be found.'
 ]
 
+{ #category : #'system startup' }
+PBPharoPipenvProcess class >> startUp: resuming [
+	"On startup any instances saved during the last session will be invalid (since the processes are terminated on shutdown).  Mark them as stopped."
+
+	resuming ifTrue: 
+		[ self allInstancesDo: [ :each | each stop ] ]
+]
+
+{ #category : #'start-stop' }
+PBPharoPipenvProcess >> debuggerStateChangedAction: aDAPThreadStateChanged [
+	"Respond to the debugger state changed notification.
+	Signal all promises that the debugger has been paused."
+
+	aDAPThreadStateChanged isStopped ifTrue:
+		[ self application notifyDebuggerPaused: serverDebugger ]
+]
+
 { #category : #accessing }
 PBPharoPipenvProcess >> environmentVariables [
 	^ environmentVariables
@@ -62,7 +96,14 @@ PBPharoPipenvProcess >> environmentVariables [
 
 { #category : #accessing }
 PBPharoPipenvProcess >> errorMessage [
-	^ process stderrStream contents
+	^ self stderr
+]
+
+{ #category : #testing }
+PBPharoPipenvProcess >> hasProcess [
+	"Answer a boolean indicating whether the receiver has a process object"
+
+	^ process isNotNil
 ]
 
 { #category : #initialization }
@@ -72,6 +113,36 @@ PBPharoPipenvProcess >> initialize [
 	self setDefaultEnvironmentVariables
 ]
 
+{ #category : #utils }
+PBPharoPipenvProcess >> installModule: aString in: aPBApplication [
+	"Install the supplied module using `pipenv run pip install aString`"
+	| pipenvPath proc arguments stdoutStream stderrStream |
+
+	pipenvPath := aPBApplication settings pipenvPath ifNil: [ self class pipenvPath ].
+	arguments := { 'run'. 'pip'. 'install'. aString. }.
+	stdoutStream := String new writeStream.
+	stderrStream := String new writeStream.
+	proc := OSSUnixSubprocess new
+		command: pipenvPath fullName;
+		arguments: arguments;
+		workingDirectory: aPBApplication workingDirectory fullName;
+		addAllEnvVariablesFromParentWithoutOverride;
+		terminateOnShutdown;
+		redirectStdout;
+		redirectStderr;
+		yourself.
+	environmentVariables associationsDo: [ :assoc |
+		proc environmentAt: assoc key put: assoc value ].
+	proc run.
+	proc
+		waitForExitPollingEvery: (Delay forMilliseconds: 500)
+		doing: [ :aProcess :outStream :errStream | 
+			stdoutStream nextPutAll: outStream upToEnd.
+			stderrStream nextPutAll: errStream upToEnd ].
+	proc isSuccess ifFalse:
+		[ self error: 'Unable to install module: ', aString asString ].
+]
+
 { #category : #testing }
 PBPharoPipenvProcess >> isRunning [
 	^ process
@@ -82,13 +153,13 @@ PBPharoPipenvProcess >> isRunning [
 { #category : #private }
 PBPharoPipenvProcess >> newProcess [
 	| newProcess |
-	newProcess := OSSUnixSubprocess new
-				command: self class pipenvPath;
+
+	newProcess := PBUnixSubprocess new
+				command: (self settings pipenvPath ifNil:
+					[ self class pipenvPath ]) fullName;
 				arguments: self processArguments;
 				workingDirectory: self workingDirectory fullName;
 				addAllEnvVariablesFromParentWithoutOverride;
-				redirectStdout;
-				redirectStderr;
 				terminateOnShutdown;
 				yourself.
 	environmentVariables associationsDo: [ :assoc |
@@ -96,6 +167,14 @@ PBPharoPipenvProcess >> newProcess [
 	^ newProcess
 ]
 
+{ #category : #accessing }
+PBPharoPipenvProcess >> pipenvPath [ 
+	"Answer the default pipenvPath.
+	This may be overridden by the application settings."
+
+	^ self class pipenvPath
+]
+
 { #category : #accessing }
 PBPharoPipenvProcess >> process [
 	^ process
@@ -104,10 +183,19 @@ PBPharoPipenvProcess >> process [
 { #category : #private }
 PBPharoPipenvProcess >> processArguments [
 	| args |
+
 	args := OrderedCollection new.
 	args
 		add: 'run';
-		add: 'python';
+		add: 'python'.
+	self settings serverDebugMode ifTrue:
+		[ args addAll: { 
+			'-m'. 
+			'debugpy'. 
+			'--listen'. 
+			self settings debugSocketAddress printAddress. 
+			'--wait-for-client'. } ].
+	args
 		add: self pythonMainFile fullName;
 		add: '--port';
 		add: self settings pythonSocketAddress port asString;
@@ -131,14 +219,55 @@ PBPharoPipenvProcess >> setDefaultEnvironmentVariables [
 { #category : #'start-stop' }
 PBPharoPipenvProcess >> start [
 	process := self newProcess.
+
 	process run.
+	self settings serverDebugMode ifTrue:
+		[ self startServerDebugger ].
+]
+
+{ #category : #'start-stop' }
+PBPharoPipenvProcess >> startServerDebugger [
+	"Start the debugger, tell the server to run and set up inspection on halt"
+
+	"Give the server time to start"
+	1 second wait.
+	serverDebugger := DAPPythonDebugger new 
+		localRoot: self workingDirectory;
+		connectTo: #[127 0 0 1] port: self settings debugSocketAddress port.
+	serverDebugger announcer 
+		when: DAPThreadStateChanged 
+		do: [ :announcement | self debuggerStateChangedAction: announcement ].
+
+]
+
+{ #category : #accessing }
+PBPharoPipenvProcess >> stderr [
+	"Answer the process stderr contents"
+
+	^ process stderr
+]
+
+{ #category : #accessing }
+PBPharoPipenvProcess >> stdout [ 
+	"Answer the process stdout contents"
+
+	^ process stdout
 ]
 
 { #category : #'start-stop' }
 PBPharoPipenvProcess >> stop [
 	process ifNil: [ ^ self ].
-	[process queryExitStatus ifNil: [ process terminate ]] 
+	[ process queryExitStatus ifNil: [ process terminate ]] 
 		on: Error 
 		do: [ :e | "Do nothing."].
-	process closeAndCleanStreams
+	process closeAndCleanStreams.
+	process := nil.
+]
+
+{ #category : #'start-stop' }
+PBPharoPipenvProcess >> stopServerDebugger [
+	"Close the debugger and deregister"
+
+	serverDebugger close.
+	serverDebugger announcer unsubscribe: self debuggerStateChangedAction
 ]
diff --git a/src/PythonBridge-Pharo/PBPharoPlatform.class.st b/src/PythonBridge-Pharo/PBPharoPlatform.class.st
index 024332c..3cfc810 100644
--- a/src/PythonBridge-Pharo/PBPharoPlatform.class.st
+++ b/src/PythonBridge-Pharo/PBPharoPlatform.class.st
@@ -1,6 +1,9 @@
 Class {
 	#name : #PBPharoPlatform,
 	#superclass : #PBPlatform,
+	#classVars : [
+		'RuntimeSourceDirectory'
+	],
 	#category : #'PythonBridge-Pharo-Platform'
 }
 
@@ -19,6 +22,21 @@ PBPharoPlatform class >> priority [
 	^ 10
 ]
 
+{ #category : #accessing }
+PBPharoPlatform class >> runtimeSourceDirectory [
+	<return: #AbstractFileReference>
+
+	^ RuntimeSourceDirectory
+]
+
+{ #category : #accessing }
+PBPharoPlatform class >> runtimeSourceDirectory: anAbstractFileReference [
+	"Set the directory the contains the runtime files.
+	nil = not specified"
+
+	RuntimeSourceDirectory := anAbstractFileReference
+]
+
 { #category : #hooks }
 PBPharoPlatform class >> socketMessageBrokerClass [
 	^ PBMsgPackPharoBroker
@@ -34,16 +52,34 @@ PBPharoPlatform class >> weakRegistryClass [
 	^ PBPharoWeakRegistry
 ]
 
-{ #category : #'private - symlinks' }
-PBPharoPlatform >> createSymlinkFor: originalFile on: targetFile [
-	OSSUnixSubprocess new
-				command: '/bin/ln';
-				arguments: (Array 
-									with: '-s' 
-									with: originalFile asFileReference fullName 
-									with: targetFile asFileReference fullName);
-				terminateOnShutdown;
-				runAndWaitOnExitDo: [ :command | ^ self ].
+{ #category : #private }
+PBPharoPlatform >> copyApplicationTo: appFolder application: application [
+	"Copy the PythonBridge runtime environment to the specified folder"
+	| srcDir cpCommand proc srcFilename dstFilename error |
+
+	srcDir := self runtimeSourceDirectoryFor: application.
+	srcDir resolve = appFolder resolve ifTrue: [ ^ self ].
+
+	"Copy the runtime directory"
+	srcFilename := srcDir resolve fullName copyReplaceAll: '"' with: '\"'.
+	dstFilename := appFolder resolve fullName copyReplaceAll: '"' with: '\"'.
+	cpCommand := String streamContents: [ :stream |
+		stream
+			<< 'cp -a "';
+			<< srcFilename;
+			<< '" "';
+			<< dstFilename;
+			<< '"' ].
+	proc := PBUnixSubprocess new 
+		shellCommand: cpCommand;
+		runAndWait.
+	proc isSuccess ifFalse:
+		[ error := PBPythonProcessError new
+			messageText: 'Unable to install PythonBridge runtime';
+			application: application;
+			process: proc.
+		error signal ].
+
 ]
 
 { #category : #'message broker strategy' }
@@ -52,64 +88,52 @@ PBPharoPlatform >> defaultMessageBrokerClass [
 ]
 
 { #category : #hooks }
-PBPharoPlatform >> ensureApplicationSymlinks: application [
+PBPharoPlatform >> ensureApplicationDirectory: application [
 	| appFolder |
-	appFolder := self folderForApplication: application.
-	self ensureFolderSymlinkFor: appFolder.
-	self ensurePBridge: (self folderForApplication: application class baseApplication) symlinkIn: appFolder
-]
 
-{ #category : #'as yet unclassified' }
-PBPharoPlatform >> ensureEnvironmentForApp: anApplication [
-	self ensureApplicationSymlinks: anApplication.
-	self installEnvironmentForApp: anApplication.
-]
+	appFolder := application workingDirectory.
+	(appFolder / 'PythonBridge') exists ifTrue: [ ^ self ].
+	self copyApplicationTo: appFolder application: application.
+	self setExecutableIn: appFolder application: application.
 
-{ #category : #'private - symlinks' }
-PBPharoPlatform >> ensureFolderSymlinkFor: aFolder [
-	| symlinkRef |
-	symlinkRef := aFolder basename asFileReference.
-	symlinkRef exists ifFalse: [ 
-		self createSymlinkFor: aFolder on: symlinkRef ]
-]
 
-{ #category : #'private - symlinks' }
-PBPharoPlatform >> ensurePBridge: pbridgeFolder symlinkIn: aFolder [
-	| symlinkRef |
-	symlinkRef := aFolder / 'PythonBridge'.
-	symlinkRef exists ifFalse: [ 
-		self createSymlinkFor: pbridgeFolder on: symlinkRef ].
 ]
 
-{ #category : #utils }
-PBPharoPlatform >> folderForApplication: application [
-	^ (IceRepository registry 
-			detect: [ :each | each includesPackageNamed: application class package name ] 
-			ifNone: [ 
-				self inform: 'Please add a clone of this project to Iceberg to access to the resources'.
-				"For travis!"
-				^ '.' asFileReference ]) location
+{ #category : #private }
+PBPharoPlatform >> ensureEnvironmentForApp: anApplication [
+
+	[ self ensureApplicationDirectory: anApplication.
+	self installEnvironmentForApp: anApplication ] asJob
+		title: 'Installing PythonBridge runtime environment';
+		run
 ]
 
 { #category : #utils }
 PBPharoPlatform >> forceInstallEnvironmentForApp: application [
-	| proc |
-	self assert: PBPharoPipenvProcess pipenvPath isEmptyOrNil not description: 'pipenv is apparently not accessible at a standard location. Please, have a look at the Troubleshooting section of https://objectprofile.github.io/PythonBridge/pages/pharo-installation'.
-	proc := OSSUnixSubprocess new
+	| proc pipenvPath |
+
+	pipenvPath := application pipenvPath.
+	self assert: pipenvPath exists description: 'pipenv is apparently not accessible at a standard location. Please, have a look at the Troubleshooting section of https://objectprofile.github.io/PythonBridge/pages/pharo-installation'.
+	proc := PBUnixSubprocess new
 				command: '/bin/bash';
-				addAllEnvVariablesFromParentWithoutOverride;
-				arguments: (Array 
-					with: ((self folderForApplication: application) / 'install_env.sh') fullName);
-				terminateOnShutdown;
-				runAndWait.
-	(proc exitStatus = 0 or: [ proc exitStatus < -1000 or: [ proc exitStatus > SmallInteger maxVal ] ]) ifFalse: [ 
-		self signalPipenvCreateEnvFailed ]
+				workingDirectory: application workingDirectory fullName;
+				addAllEnvVariablesFromParentWithoutOverride.
+	proc
+		environmentAt: 'PATH'
+		put: pipenvPath parent fullName,
+				':', (proc envVariables at: 'PATH').
+	proc
+		arguments: (Array 
+			with: (application workingDirectory / 'install_env.sh') fullName);
+		terminateOnShutdown;
+		runAndWait.
+	proc isSuccess ifFalse: [ self signalPipenvCreateEnvFailed: application process: proc ].
 ]
 
 { #category : #utils }
 PBPharoPlatform >> installEnvironmentForApp: application [
 	| folder |
-	folder := self folderForApplication: application.
+	folder := application workingDirectory.
 	(folder / '.venv') exists ifFalse: [ 
 		self forceInstallEnvironmentForApp: application ]
 ]
@@ -119,15 +143,65 @@ PBPharoPlatform >> newRandomName [
 	^ 'pb' , UUID new asString36
 ]
 
+{ #category : #utils }
+PBPharoPlatform >> runtimeSourceDirectoryFor: aPBApplication [
+	"Answer the source directory containing the runtime files.
+	This is the first of:
+	1. RuntimeSourceDirectory (if specified)
+	2. The git repository copy.
+	3. An existing copy in the image directory"
+	| fileReference |
+
+	(RuntimeSourceDirectory isNotNil and: [ RuntimeSourceDirectory exists ]) ifTrue: 
+		[ ^ RuntimeSourceDirectory ].
+	IceRepository registry 
+			detect: [ :each | each includesPackageNamed: aPBApplication class package name ] 
+			ifFound: [ :repository | 
+					fileReference := repository location / 'PythonBridgeRuntime'.
+					fileReference exists ifTrue: [ ^ fileReference ] ]
+			ifNone: [ ].
+	fileReference := FileLocator imageDirectory / 'PythonBridgeRuntime'.
+	fileReference exists ifTrue: [ ^ fileReference ].
+	self error: 'Unable to locate PythonBridge runtime source'.
+]
+
+{ #category : #private }
+PBPharoPlatform >> setExecutableIn: appFolder application: application [
+	"Copy the PythonBridge runtime environment to the specified folder"
+	| chmodCommand proc error appFolderString |
+
+	appFolderString := appFolder resolve fullName copyReplaceAll: '"' with: '\"'.
+	chmodCommand := String streamContents: [ :stream |
+		stream
+			<< 'chmod +x "';
+			<< appFolderString;
+			<< '"/*.sh' ].
+	proc := OSSUnixSubprocess new 
+		shellCommand: chmodCommand;
+		runAndWait.
+	proc isSuccess ifFalse:
+		[ error := PBPythonProcessError new
+			messageText: 'Unable to set PythonBridge runtime executable bits';
+			application: application;
+			process: proc.
+		error signal ].
+
+]
+
 { #category : #private }
-PBPharoPlatform >> signalPipenvCreateEnvFailed [
-	"
-	Python bridge attempt of creating Pipenv environment failed. To attempt to generate the Pipenv
-	environment manually go the project git folder. It may be the PythonBridge, KerasBridge or your
-	Bridge, because each of them has a different Pipfile and Pipenv environment.
+PBPharoPlatform >> signalPipenvCreateEnvFailed: application process: proc [
+	"The attempt to install the python environment failed.
+	Signal the error.
+
+	To manually track down the issue, go to the working directory as shown in the signal and:
 	
 	To remove the current Pipenv environment run in the folder the command: `pipenv --rm`
-	To manually create the Pipenv environment run in the folder the command: `bash install_env.sh`
-	"
-	Error signal: 'Attempt for creating Pipenv environment failed.'
+	To manually create the Pipenv environment run in the folder the command: `bash install_env.sh`"
+	| error |
+
+	"Save the error in a temporary variable for access while debugging since the debugger hides the signal stack entries"
+	error := PBPythonProcessError new
+		application: application;
+		process: proc.
+	error signal
 ]
diff --git a/src/PythonBridge-Pharo/PBUnixSubprocess.class.st b/src/PythonBridge-Pharo/PBUnixSubprocess.class.st
new file mode 100644
index 0000000..ffa8f88
--- /dev/null
+++ b/src/PythonBridge-Pharo/PBUnixSubprocess.class.st
@@ -0,0 +1,324 @@
+"
+PBUnixSubprocess is a convenience wrapper around OSSUnixSubprocess for the common case of executing a command and capturing stdout and stderr, which are strings and are larger than one OS buffer, but small enough to fit in RAM.
+
+Typical usage is: 
+
+``` 
+proc := (PBUnixSubprocess command: 'ls' arguments: #('-lh'))
+proc errorBlock: [ :proc | self error: 'External process failed, see proc' ].
+proc runAndWait
+proc stdout
+```
+
+If no error block is supplied the completion status should be checked with `#isSuccess`.
+
+
+Public API and Key Messages
+
+- command:arguments: 	(class) create an instance with the supplied parameters
+- errorBlock: 			Set the block to be evaluated if the process exits unsuccessfully.
+		Note that this is only called if the process is successfully started and subsequently fails.
+		Supplying a non-existing path, or a command that can't be found, will raise an error in the calling process.
+- removeLD_LIBRARY_PATH: 	Remove LD_LIBRARY_PATH from the environment passed to the subprocess.
+		This is useful on linux if the command expects the system installation of openssl.
+- runAndWait: 			Execute the command and wait for completion.
+- isSuccess 				Answer a boolean indicating if the command completed successfully.
+- stdout, stderr: 		The output strings.
+
+ 
+## Internal Representation and Key Implementation Points.
+
+
+### Instance Variables
+
+	arguments:		<Array>
+	command:			<String>
+	errorBlock:		<BlockClosure>
+	process:			<OSSUnixSubprocess>
+	semaphore:		<Semaphore>
+	stderrStream:	<WriteStream on: String>
+	stdoutStream:	<WriteStream on: String>
+
+
+### Implementation Points
+
+
+"
+Class {
+	#name : #PBUnixSubprocess,
+	#superclass : #Object,
+	#instVars : [
+		'command',
+		'arguments',
+		'shellCommand',
+		'process',
+		'semaphore',
+		'errorBlock',
+		'workingDirectory',
+		'stdoutStream',
+		'stderrStream'
+	],
+	#category : #'PythonBridge-Pharo-Processes'
+}
+
+{ #category : #'instance creation' }
+PBUnixSubprocess class >> command: cmd arguments: args [
+
+	^self new
+		command: cmd;
+		arguments: args.
+]
+
+{ #category : #adding }
+PBUnixSubprocess >> addAllEnvVariablesFromParentWithoutOverride [
+
+	self process addAllEnvVariablesFromParentWithoutOverride
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> arguments [
+	^ arguments
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> arguments: anObject [
+	arguments := anObject
+]
+
+{ #category : #cleaning }
+PBUnixSubprocess >> closeAndCleanStreams [
+
+	process ifNil: [ ^ self ].
+	process closeAndCleanStreams.
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> command [
+	^ command
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> command: anObject [
+	command := anObject
+]
+
+{ #category : #'env building' }
+PBUnixSubprocess >> envVariables [
+
+	^ process envVariables
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> environmentAt: key put: value [
+
+	^ self process environmentAt: key put: value
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> errorBlock [
+	^ errorBlock
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> errorBlock: anObject [
+	errorBlock := anObject
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> exitCode [ 
+	"Answer the interpretted exit status, or nil if not available"
+
+	(process isNil or: [ process isRunning ]) ifTrue: [ ^ nil ].
+	^ process exitStatusInterpreter exitStatus
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> exitStatus [ 
+
+	^ process exitStatus
+]
+
+{ #category : #status }
+PBUnixSubprocess >> exitStatusInterpreter [
+
+	^ process exitStatusInterpreter
+]
+
+{ #category : #testing }
+PBUnixSubprocess >> hasProcess [
+	"Answer a boolean indicating whether the receiver has a process object"
+
+	^ process isNotNil
+]
+
+{ #category : #initialization }
+PBUnixSubprocess >> initialize [
+
+	super initialize.
+	arguments := #().
+]
+
+{ #category : #testing }
+PBUnixSubprocess >> isRunning [ 
+
+	^ self process isRunning
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> isSuccess [
+	"Answer whether the command completed successfully.
+	Only valid after the command has completed."
+	
+	^process exitStatusInterpreter isSuccess
+]
+
+{ #category : #printing }
+PBUnixSubprocess >> printOn: aStream [
+
+	process ifNil: [ ^super printOn: aStream ].
+	process isRunning ifTrue:
+		[ aStream nextPutAll: 'a Running GtUnixSubprocess' ]
+	ifFalse:
+		[ self isSuccess ifTrue: 
+				[ aStream nextPutAll: 'a Successfull GtUnixSubprocess' ]
+			ifFalse:
+				[ aStream nextPutAll: 'an Unsuccessfull GtUnixSubprocess' ] ].
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> process [
+
+	^ process ifNil: [ process := OSSUnixSubprocess new ]
+]
+
+{ #category : #status }
+PBUnixSubprocess >> queryExitStatus [
+
+	^ process queryExitStatus
+]
+
+{ #category : #removing }
+PBUnixSubprocess >> removeLD_LIBRARY_PATH [
+	"The script for running pharo sets LD_LIBRARY_PATH to the VM directory, which contains non-standard libraries.
+	Unset LD_LIBRARY_PATH."
+
+	self process addAllEnvVariablesFromParentWithoutOverride.
+	self process envVariables removeKey: 'LD_LIBRARY_PATH'.
+]
+
+{ #category : #running }
+PBUnixSubprocess >> run [
+	"Run the command without waiting"
+
+	semaphore := nil.
+	^self runProcess
+]
+
+{ #category : #running }
+PBUnixSubprocess >> runAndWait [
+	"Run the command and wait for completion"
+
+	semaphore := Semaphore new.
+	self runProcess.
+	semaphore wait.
+	(errorBlock isNotNil and: [ self isSuccess not ])
+		ifTrue: [ errorBlock value: self ]
+]
+
+{ #category : #private }
+PBUnixSubprocess >> runProcess [
+	"Run the requested command as a separate process"
+
+	self setCommand.
+	stdoutStream := String new writeStream.
+	stderrStream := String new writeStream.
+	self process
+		redirectStdout;
+		redirectStderr.
+	workingDirectory ifNotNil: 
+		[ self process workingDirectory: workingDirectory fullName ].
+	self process run.
+
+	[ self process
+		waitForExitPollingEvery: (Delay forMilliseconds: 500)
+		doing: [ :proc :outStream :errStream | 
+			stdoutStream nextPutAll: outStream upToEnd.
+			stderrStream nextPutAll: errStream upToEnd ].
+	self process closeAndCleanStreams.
+	"Async processes have errors signalled here.
+	If waiting, raise the error after signalling the semaphore (in #runAndWait)"
+	semaphore
+		ifNil: [ (errorBlock isNotNil and: [ self isSuccess not ])
+				ifTrue: [ errorBlock value: self ] ]
+		ifNotNil: [ semaphore signal ] ] fork.
+
+]
+
+{ #category : #private }
+PBUnixSubprocess >> setCommand [
+	"Set the command or shell command in the process.
+	Either may be specified, but not both :-)"
+
+	(command isNil and: [ shellCommand isNil ]) ifTrue: 
+		[ self error: 'No command supplied' ].
+	(command isNotNil and: [ shellCommand isNotNil ]) ifTrue: 
+		[ self error: 'Only one of a command or shell command may be supplied' ].
+
+	command ifNil: 
+		[ self process shellCommand: shellCommand ]
+	ifNotNil:
+		[ self process
+			command: command;
+			arguments: arguments ].
+
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> shellCommand [
+	^ shellCommand
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> shellCommand: anObject [
+	shellCommand := anObject
+]
+
+{ #category : #'OS signal sending' }
+PBUnixSubprocess >> sigterm [
+	"Ask the external process to terminate"
+
+	^process sigterm
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> stderr [
+	^ stderrStream contents
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> stdout [
+	^ stdoutStream contents
+]
+
+{ #category : #actions }
+PBUnixSubprocess >> terminate [
+
+	process terminate
+]
+
+{ #category : #'system startup & shutdown' }
+PBUnixSubprocess >> terminateOnShutdown [
+
+	self process terminateOnShutdown
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> workingDirectory [
+	^ workingDirectory
+]
+
+{ #category : #accessing }
+PBUnixSubprocess >> workingDirectory: aFileReference [
+
+	workingDirectory := aFileReference asFileReference
+]
diff --git a/src/PythonBridge/PBAbstractProcess.class.st b/src/PythonBridge/PBAbstractProcess.class.st
index 8066e27..98d644f 100644
--- a/src/PythonBridge/PBAbstractProcess.class.st
+++ b/src/PythonBridge/PBAbstractProcess.class.st
@@ -3,18 +3,15 @@ Class {
 	#superclass : #Object,
 	#instVars : [
 		'pythonMainFile',
-		'debugMode',
-		'settings',
-		'workingDirectory'
+		'workingDirectory',
+		'application'
 	],
 	#category : #'PythonBridge-Platform'
 }
 
 { #category : #accessing }
 PBAbstractProcess class >> application: application [
-	^ self 
-		settings: application settings 
-		application: application
+	^ self new application: application
 ]
 
 { #category : #accessing }
@@ -22,44 +19,26 @@ PBAbstractProcess class >> platform [
 	self subclassResponsibility
 ]
 
-{ #category : #accessing }
-PBAbstractProcess class >> settings: settings application: application [
-	^ self 
-		settings: settings 
-		workingDirectory: (PBPlatform current folderForApplication: application)
-		debugMode: application class debugMode
-]
+{ #category : #hooks }
+PBAbstractProcess class >> workingDirectory [
 
-{ #category : #accessing }
-PBAbstractProcess class >> settings: settings workingDirectory: fileRef [
-	^ self new
-		settings: settings;
-		workingDirectory: fileRef;
-		yourself
+	self deprecated: 'This should be run against a PBApplication instance that knows its runtime directory'.
+	"^ self platform runtimeFolderForApplication: PBApplication"
 ]
 
 { #category : #accessing }
-PBAbstractProcess class >> settings: settings workingDirectory: fileRef debugMode: flag [
-	^ self new
-		settings: settings;
-		workingDirectory: fileRef;
-		debugMode: flag;
-		yourself
-]
-
-{ #category : #hooks }
-PBAbstractProcess class >> workingDirectory [
-	^ self platform folderForApplication: PBApplication
+PBAbstractProcess >> application [
+	^ application
 ]
 
 { #category : #accessing }
-PBAbstractProcess >> debugMode [
-	^ debugMode
+PBAbstractProcess >> application: anObject [
+	application := anObject
 ]
 
 { #category : #accessing }
-PBAbstractProcess >> debugMode: anObject [
-	debugMode := anObject
+PBAbstractProcess >> debugMode [
+	^ self settings debugMode
 ]
 
 { #category : #accessing }
@@ -67,12 +46,6 @@ PBAbstractProcess >> errorMessage [
 	self subclassResponsibility
 ]
 
-{ #category : #initialization }
-PBAbstractProcess >> initialize [
-	super initialize.
-	debugMode := false
-]
-
 { #category : #testing }
 PBAbstractProcess >> isRunning [
 	self subclassResponsibility
@@ -90,12 +63,7 @@ PBAbstractProcess >> pythonMainFile: anObject [
 
 { #category : #accessing }
 PBAbstractProcess >> settings [
-	^ settings
-]
-
-{ #category : #accessing }
-PBAbstractProcess >> settings: anObject [
-	settings := anObject
+	^ application settings
 ]
 
 { #category : #'start-stop' }
@@ -110,10 +78,5 @@ PBAbstractProcess >> stop [
 
 { #category : #accessing }
 PBAbstractProcess >> workingDirectory [
-	^ workingDirectory
-]
-
-{ #category : #accessing }
-PBAbstractProcess >> workingDirectory: anObject [
-	workingDirectory := anObject
+	^ application workingDirectory
 ]
diff --git a/src/PythonBridge/PBApplication.class.st b/src/PythonBridge/PBApplication.class.st
index 0c0e451..d453ea7 100644
--- a/src/PythonBridge/PBApplication.class.st
+++ b/src/PythonBridge/PBApplication.class.st
@@ -44,11 +44,39 @@ PBApplication class >> do: aBlockClosure [
 	^ retVal
 ]
 
+{ #category : #initialization }
+PBApplication class >> initialize [
+	SessionManager default registerToolClassNamed: self name
+]
+
 { #category : #testing }
 PBApplication class >> isRunning [
 	^ uniqueInstance notNil and: [ uniqueInstance isRunning ]
 ]
 
+{ #category : #'start-stop' }
+PBApplication class >> killAll [
+	"Stop ALL PBApplication instances and kill any server processes that may still be running."
+	| allInstances firstApplication wd proc error |
+
+	allInstances := self allInstances.
+	allInstances ifEmpty: [ ^ self ].
+	firstApplication := allInstances
+		detect: #isRunning 
+		ifNone: [ allInstances first ].
+	allInstances do: #stop.
+	wd := firstApplication workingDirectory.
+	proc := PBUnixSubprocess new command: (wd / 'killpbservers.sh') fullName.
+	proc runAndWait.
+	proc isSuccess ifFalse: 
+		[ error:= PBPythonProcessError new
+		application: firstApplication;
+		process: proc.
+		error signal ].
+	self assert: proc stderr trimBoth isEmpty.
+	^ proc stdout
+]
+
 { #category : #testing }
 PBApplication class >> module [
 	^ self uniqueInstance module
@@ -61,7 +89,9 @@ PBApplication class >> platform [
 
 { #category : #'python hooks file' }
 PBApplication class >> repositoryFileReference [
-	^ self platform folderForApplication: self
+
+	self deprecated: 'This should be run against a PBApplication instance that knows its runtime directory'.
+	"^ self platform runtimeFolderForApplication: self"
 ]
 
 { #category : #instructions }
@@ -73,17 +103,30 @@ PBApplication class >> resetUniqueInstance [
 	uniqueInstance := nil
 ]
 
+{ #category : #accessing }
+PBApplication class >> runtimeDirectory [
+	"This is the directory basename where the runtime files are located"
+
+	^ 'PythonBridgeRuntime'
+]
+
 { #category : #instructions }
 PBApplication class >> send: obj [
 	self assert: self isRunning.
 	^ self uniqueInstance send: obj
 ]
 
+{ #category : #accessing }
+PBApplication class >> shutdown: isImageQuitting [
+	isImageQuitting ifTrue: [ self stop ]
+]
+
 { #category : #'start-stop' }
 PBApplication class >> start [
 	self isRunning ifTrue: [ Error signal: 'Keras already running.' ].
 	self stop.
 	uniqueInstance := self new.
+	PBCF reset.
 	uniqueInstance commandFactory reset.
 	uniqueInstance start
 ]
@@ -109,6 +152,7 @@ PBApplication class >> test [
 
 { #category : #instructions }
 PBApplication class >> uniqueInstance [
+	uniqueInstance ifNil: [ self start ].
 	^ uniqueInstance
 ]
 
@@ -137,7 +181,8 @@ PBApplication >> communicationHandler [
 { #category : #accessing }
 PBApplication >> errorMessage [
 	"Fetch the error message from the stderr stream, from the processhander"
-	^ processHandler errorMessage
+
+	^ self serverStatus
 ]
 
 { #category : #accessing }
@@ -145,6 +190,27 @@ PBApplication >> executionHandler [
 	^ executionHandler
 ]
 
+{ #category : #ui }
+PBApplication >> gtSettingsFor: aView [
+	<gtView>
+
+	^ aView forward 
+		title: 'Settings';
+		priority: 60;
+		object: [ settings ];
+		view: #gtSettingsFor:
+]
+
+{ #category : #ui }
+PBApplication >> gtStatusFor: aView [
+	<gtView>
+
+	^ aView textEditor 
+		title: 'Status';
+		priority: 50;
+		text: [ self serverStatus asRopedText glamorousCodeFont ]
+]
+
 { #category : #handlers }
 PBApplication >> handlers [
 	^ Array
@@ -169,6 +235,13 @@ PBApplication >> initializeHandlers [
 	executionHandler := PBExecutionHandler application: self
 ]
 
+{ #category : #utils }
+PBApplication >> installModule: aString [
+	"Install the supplied module using `pipenv run pip install aString`"
+
+	PBPharoPipenvProcess new installModule: aString in: self
+]
+
 { #category : #testing }
 PBApplication >> isPythonReady [
 	"Ensures python webserver is ready for receiving commands"
@@ -200,27 +273,113 @@ PBApplication >> newCommandFactory [
 	^ self executionHandler newCommandFactory
 ]
 
+{ #category : #'instance creation' }
+PBApplication >> newCommandStringFactory [
+	^ self executionHandler newCommandStringFactory
+]
+
+{ #category : #instructions }
+PBApplication >> notifyDebuggerPaused: aDebugger [
+	"Notify all promises that the server debugger has paused in case the Bloc UI process is waiting on one of the promises."
+
+	self executionHandler notifyDebuggerPaused: aDebugger.
+]
+
+{ #category : #accessing }
+PBApplication >> pipenvPath [ 
+	"Answer the pipenvPath to be used for this application"
+
+	^ settings pipenvPath ifNil: [ processHandler pipenvPath ]
+]
+
 { #category : #accessing }
 PBApplication >> postInitialization [
 	
 ]
 
+{ #category : #printing }
+PBApplication >> printOn: aStream [
+
+	aStream
+		<< self class name;
+		<< '('.
+	self isRunning ifFalse:
+		[ aStream << 'not running)'.
+		^ self ].
+	aStream
+		print: settings pharoSocketAddress;
+		<< ', ';
+		print: settings pythonSocketAddress;
+		<< ')'
+]
+
 { #category : #accessing }
 PBApplication >> processHandler [
 	^ processHandler
 ]
 
-{ #category : #'as yet unclassified' }
+{ #category : #utils }
 PBApplication >> registerObject: aPythonObject [
 	self executionHandler registerObject: aPythonObject
 ]
 
+{ #category : #accessing }
+PBApplication >> runtimeDirectory [
+	"This is the directory basename where the runtime files are located"
+
+	^ self class runtimeDirectory
+]
+
 { #category : #instructions }
 PBApplication >> send: aCommand [
 	self isRunning ifFalse: [ Error signal: 'Bridge not running.' ].
 	^ executionHandler sendCommand: aCommand
 ]
 
+{ #category : #'start-stop' }
+PBApplication >> serverStatus [
+	"Answer a string describing the environment and server status.
+	Mostly for problem solving."
+
+	^ String streamContents: [ :stream |
+		self serverStatusOn: stream process: processHandler ]
+]
+
+{ #category : #'start-stop' }
+PBApplication >> serverStatusOn: aStream process: process [
+	"Write the environment and server status on the supplied stream.
+	Mostly for problem solving."
+	| serverPathString |
+
+	serverPathString := [ self pipenvPath isExecutable
+		ifTrue: [ self pipenvPath fullName ]
+		ifFalse: [ self pipenvPath fullName, ': doesn''t exist or isn''t executable, it should be in the PATH' ] ]
+			on: Error
+			do: [ '<Unable to determine server path.  It should be in the PATH>' ].
+
+	aStream
+		<< 'Running:           ';
+			print: self isRunning; cr;
+		<< 'pipenv:            ';
+			<< serverPathString; cr;
+		<< 'Working directory: ';
+			<< self workingDirectory fullName; cr;
+		<< 'Server running:    ';
+			print: process isRunning; cr.
+	process hasProcess ifFalse: [ ^ self ].
+	process isRunning ifFalse: 
+		[ aStream
+			<< 'exit status:       ';
+				print: process exitStatusInterpreter exitStatus; cr ].
+	aStream
+		cr; cr;
+		<< 'Stdout:'; cr;
+			<< process stdout; cr;
+		cr; cr;
+		<< 'Stderr:'; cr;
+			<< process stderr.
+]
+
 { #category : #accessing }
 PBApplication >> settings [
 	^ settings
@@ -231,31 +390,43 @@ PBApplication >> settings: anObject [
 	settings := anObject
 ]
 
-{ #category : #accessing }
+{ #category : #'start-stop' }
 PBApplication >> start [
 	self handlers do: #start.
-	self commandFactory reset.
 	self waitInitialization.
 	self postInitialization.
-	self commandFactory send.
+	self newCommandFactory send.
 ]
 
-{ #category : #'as yet unclassified' }
+{ #category : #'start-stop' }
 PBApplication >> stop [
 	self handlers select: #notNil thenDo: #stop
 ]
 
-{ #category : #'as yet unclassified' }
+{ #category : #private }
 PBApplication >> waitInitialization [
 	"Timeout of 10 seconds and try every 0.5 seconds"
+	| error |
+
 	1 to: 10 by: 0.5 do: [ :t |
 		self isPythonReady 
 				ifTrue: [ ^ self ]
 				ifFalse: [ (Delay forMilliseconds: 500) wait ] ].
-	Error signal: 'Python application initialization failed! You should try to manually install the Pipenv environment. Have a look at the section "Manually creating Pipenv environment" in https://objectprofile.github.io/PythonBridge/pages/pharo-installation'.
+	"Store the error in a temporary variable since the debugger sometimes hides the parent stack frames."
+	error := PBPythonProcessError new
+		messageText: 'Python application initialization failed!';
+		application: self.
+	error signal.
 	"
 	Print the result of executing the following line:
 	
 	self errorMessage
 	"
 ]
+
+{ #category : #accessing }
+PBApplication >> workingDirectory [ 
+
+	^ settings workingDirectory ifNil: 
+		[ FileLocator imageDirectory / self runtimeDirectory ]
+]
diff --git a/src/PythonBridge/PBCommand.class.st b/src/PythonBridge/PBCommand.class.st
index df888f3..ea2c131 100644
--- a/src/PythonBridge/PBCommand.class.st
+++ b/src/PythonBridge/PBCommand.class.st
@@ -89,7 +89,7 @@ PBCommand >> promise: anObject [
 	promise := anObject
 ]
 
-{ #category : #'as yet unclassified' }
+{ #category : #accessing }
 PBCommand >> pythonCode [
 	| py3CodeStream |
 	py3CodeStream := String new writeStream.
diff --git a/src/PythonBridge/PBCommandQueue.class.st b/src/PythonBridge/PBCommandQueue.class.st
index 16a6f62..46d49f4 100644
--- a/src/PythonBridge/PBCommandQueue.class.st
+++ b/src/PythonBridge/PBCommandQueue.class.st
@@ -67,19 +67,20 @@ PBCommandQueue >> finishCommand: aCommand [
 { #category : #accessing }
 PBCommandQueue >> finishCommandId: id [
 	| commandIndex |
-	self currentCommand ifNotNil: [ :command |
-		command id = id 
-			ifTrue: [ 
-				self cleanIndex: currentIndex.
-				currentIndex := currentIndex + 1.
-				^ true ] ].
-	commandIndex := innerCollection detectIndex: [ :command | command id = id ].
-	commandIndex > currentIndex 
-		ifTrue: [ 
-			currentIndex := commandIndex + 1.
-			self log: (PBErrorLog message: 'Out of sync command queue. Pharo is delayed.') ]
-		ifFalse: [ 
-			self log: (PBErrorLog message: 'Out of sync command queue. Python is delayed.') ].
+	self currentCommand
+		ifNotNil: [ :command | 
+			command id = id
+				ifTrue: [ self cleanIndex: currentIndex.
+					currentIndex := currentIndex + 1.
+					^ true ] ].
+	commandIndex := innerCollection
+		detectIndex: [ :command | command id = id ].
+	commandIndex > currentIndex
+		ifTrue: [ currentIndex := commandIndex + 1.
+			self
+				trace: (PBErrorLog message: 'Out of sync command queue. Pharo is delayed.') ]
+		ifFalse: [ self
+				trace: (PBErrorLog message: 'Out of sync command queue. Python is delayed.') ].
 	self cleanIndex: commandIndex.
 	^ false
 ]
diff --git a/src/PythonBridge/PBCommandString.class.st b/src/PythonBridge/PBCommandString.class.st
new file mode 100644
index 0000000..09ecfa7
--- /dev/null
+++ b/src/PythonBridge/PBCommandString.class.st
@@ -0,0 +1,12 @@
+Class {
+	#name : #PBCommandString,
+	#superclass : #PBCommand,
+	#category : #'PythonBridge-Execution'
+}
+
+{ #category : #accessing }
+PBCommandString >> pythonCode [
+
+	^ instructions
+
+]
diff --git a/src/PythonBridge/PBCommandStringFactory.class.st b/src/PythonBridge/PBCommandStringFactory.class.st
new file mode 100644
index 0000000..7fed13f
--- /dev/null
+++ b/src/PythonBridge/PBCommandStringFactory.class.st
@@ -0,0 +1,100 @@
+"
+PBCommandStringFactory is variant of the command factory that takes two strings to build the set of statements:
+
+- script: a python script that will be evaluated on the remote.
+- resultExpression: a single python expression whose value will be returned.
+
+Note that PBCommandStringFactory no longer uses the instructions instance variable from ${class:name=PBCommandFactory}$.
+
+Example usage:
+
+[[[ 
+self application newCommandStringFactory
+	script: 
+'a = 4
+b = 3';
+	resultExpression: 'a + b';
+	sendAndWait
+]]]
+"
+Class {
+	#name : #PBCommandStringFactory,
+	#superclass : #PBCommandFactory,
+	#instVars : [
+		'script',
+		'resultExpression'
+	],
+	#category : #'PythonBridge-Execution'
+}
+
+{ #category : #streaming }
+PBCommandStringFactory >> << anObject [
+
+	self error: 'PBCommandStringFactory expects a single python script'
+]
+
+{ #category : #api }
+PBCommandStringFactory >> addAllBindings: aDictionary [
+	"Add the supplied key / value pairs as bindings to the receiver"
+
+	aDictionary keysAndValuesDo: [ :key :value |
+		self bindingAt: key put: value ]
+]
+
+{ #category : #streaming }
+PBCommandStringFactory >> append: aPythonStatement [
+
+	self error: 'PBCommandStringFactory expects a single python script'
+]
+
+{ #category : #accessing }
+PBCommandStringFactory >> instructionsWithNotifyAtEnd [
+
+	^ String streamContents: [ :stream |
+		stream 
+			<< script withUnixLineEndings;
+			lf;
+			<< 'notify(';
+			<< resultExpression;
+			<< ', ';
+			print: command id;
+			<< ')' ].
+
+]
+
+{ #category : #initialization }
+PBCommandStringFactory >> reset [
+	script := ''.
+	resultExpression := #None.
+	bindingsDictionary := Dictionary new.
+	observers := OrderedCollection new.
+	command := PBCommandString new.
+	transformBlock := #yourself
+]
+
+{ #category : #accessing }
+PBCommandStringFactory >> resultExpression [
+	<return: #String>
+
+	^ resultExpression
+]
+
+{ #category : #accessing }
+PBCommandStringFactory >> resultExpression: aString [
+
+	resultExpression := aString
+]
+
+{ #category : #accessing }
+PBCommandStringFactory >> script [
+	<return: #String>
+
+	^ script
+]
+
+{ #category : #accessing }
+PBCommandStringFactory >> script: aString [
+	"Set the Python script to be executed on the remote"
+
+	script := aString
+]
diff --git a/src/PythonBridge/PBCommandStringFactoryTest.class.st b/src/PythonBridge/PBCommandStringFactoryTest.class.st
new file mode 100644
index 0000000..9b2072e
--- /dev/null
+++ b/src/PythonBridge/PBCommandStringFactoryTest.class.st
@@ -0,0 +1,41 @@
+Class {
+	#name : #PBCommandStringFactoryTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'factory'
+	],
+	#category : #'PythonBridge-Tests'
+}
+
+{ #category : #initialization }
+PBCommandStringFactoryTest >> setUp [
+	factory := PBCommandStringFactory new
+]
+
+{ #category : #tests }
+PBCommandStringFactoryTest >> testBuildEmptyCommand [
+	| command |
+	command := factory buildCommand.
+	self assert: command class equals: PBCommandString.
+	self assert: (command pythonCode trimLeft beginsWith: 'notify(None,').
+	self assert: command bindings isEmpty
+]
+
+{ #category : #tests }
+PBCommandStringFactoryTest >> testBuildFullCommand [
+	| command |
+
+	factory script: 'foo'.
+	factory bindingAt: #myVar put: 3.
+	command := factory buildCommand.
+	self assert: command pythonCode lines first equals: 'foo'.
+	self assert: (command bindingsDictionary at: #myVar) equals: 3
+]
+
+{ #category : #tests }
+PBCommandStringFactoryTest >> testBuildWithObservers [
+	| command |
+	factory observerFromCallback: [ 32 ].
+	command := factory buildCommand.
+	self assert: command observers first callback value equals: 32.
+]
diff --git a/src/PythonBridge/PBCommandStringTest.class.st b/src/PythonBridge/PBCommandStringTest.class.st
new file mode 100644
index 0000000..87a69a7
--- /dev/null
+++ b/src/PythonBridge/PBCommandStringTest.class.st
@@ -0,0 +1,30 @@
+Class {
+	#name : #PBCommandStringTest,
+	#superclass : #TestCase,
+	#category : #'PythonBridge-Tests'
+}
+
+{ #category : #tests }
+PBCommandStringTest >> testNewCommandHasEmtptyBindings [
+	| command |
+	command := PBCommandString new.
+	self assert: command id isString.
+	self assert: command id notEmpty.
+	self assert: command bindings equals: #().
+]
+
+{ #category : #tests }
+PBCommandStringTest >> testNotValidBindingsKeyNotString [
+	| command |
+	command := PBCommandString new.
+	command bindings: { 33 -> 'bar' }.
+	self deny: command isValid
+]
+
+{ #category : #tests }
+PBCommandStringTest >> testNotValidBindingsNotAssoc [
+	| command |
+	command := PBCommandString new.
+	command bindings: { '33' -> 'bar'. 'foo' }.
+	self deny: command isValid
+]
diff --git a/src/PythonBridge/PBCommunicationHandler.class.st b/src/PythonBridge/PBCommunicationHandler.class.st
index a191cec..a62342d 100644
--- a/src/PythonBridge/PBCommunicationHandler.class.st
+++ b/src/PythonBridge/PBCommunicationHandler.class.st
@@ -24,7 +24,7 @@ PBCommunicationHandler >> isPythonReady [
 	semaphore := Semaphore new.
 	[ ans := [self sendMessage: PBIsAliveMessage new.
 				true ] 
-					on: PBCommunicationError 
+					on: PBCommunicationError, PrimitiveFailed
 					do: [ :e | false ].
 	semaphore signal ] forkAt: Processor lowIOPriority.
 	semaphore waitTimeoutMSecs: 100.
diff --git a/src/PythonBridge/PBDebuggerPaused.class.st b/src/PythonBridge/PBDebuggerPaused.class.st
new file mode 100644
index 0000000..f8281e3
--- /dev/null
+++ b/src/PythonBridge/PBDebuggerPaused.class.st
@@ -0,0 +1,32 @@
+Class {
+	#name : #PBDebuggerPaused,
+	#superclass : #PBRemoteNotification,
+	#instVars : [
+		'debugger'
+	],
+	#category : #'PythonBridge-ErrorHandling'
+}
+
+{ #category : #accessing }
+PBDebuggerPaused >> debugger [
+	^ debugger
+]
+
+{ #category : #accessing }
+PBDebuggerPaused >> debugger: anObject [
+	debugger := anObject
+]
+
+{ #category : #exceptiondescription }
+PBDebuggerPaused >> defaultAction [
+	"No one has handled this error, but now give them a chance to decide how to debug it.  If none handle this either then open debugger (see UnhandedError-defaultAction)"
+
+	^ UnhandledError signalForException: self
+]
+
+{ #category : #initialization }
+PBDebuggerPaused >> setWaitAgain [
+	"Flag the receiver's promise that it should wait for another value"
+
+	promise setWaitAgain.
+]
diff --git a/src/PythonBridge/PBExecutionHandler.class.st b/src/PythonBridge/PBExecutionHandler.class.st
index fb58fb1..1a45015 100644
--- a/src/PythonBridge/PBExecutionHandler.class.st
+++ b/src/PythonBridge/PBExecutionHandler.class.st
@@ -67,6 +67,13 @@ PBExecutionHandler >> newCommandFactory [
 		yourself
 ]
 
+{ #category : #'as yet unclassified' }
+PBExecutionHandler >> newCommandStringFactory [
+	^ PBCommandStringFactory new
+		application: self application;
+		yourself
+]
+
 { #category : #handlers }
 PBExecutionHandler >> notifyCallbackHandler: msg [
 	| val serialization |
@@ -81,6 +88,13 @@ PBExecutionHandler >> notifyCallbackHandler: msg [
 		yourself
 ]
 
+{ #category : #instructions }
+PBExecutionHandler >> notifyDebuggerPaused: aDebugger [
+	"Notify all promises that the server debugger has paused in case the Bloc UI process is waiting on one of the promises."
+
+	promiseRegistry notifyDebuggerPaused: aDebugger.
+]
+
 { #category : #handlers }
 PBExecutionHandler >> notifyErrorHandler: errorMsg [
 	| error |
@@ -137,12 +151,9 @@ PBExecutionHandler >> registerPromiseForCommand: aCommand [
 
 { #category : #'as yet unclassified' }
 PBExecutionHandler >> safeTriggerDebugger: error [
-	| sem |
-	sem := Semaphore new.
-	[ [ self triggerDebugger: error ] ensure: [ sem signal ] ]
-		on: PBPythonError fork: [ :e | PBPlatform current uiManager spawnDebuggerOnException: e ].
-	sem wait.
-	^ error proceedAction: error defaultProceedAction
+
+	[ promiseRegistry signalPromiseId: error command id with: error ] fork.
+
 ]
 
 { #category : #'private protocol' }
diff --git a/src/PythonBridge/PBMessageBrokerTest.class.st b/src/PythonBridge/PBMessageBrokerTest.class.st
index 7ed7016..1daf7dd 100644
--- a/src/PythonBridge/PBMessageBrokerTest.class.st
+++ b/src/PythonBridge/PBMessageBrokerTest.class.st
@@ -81,9 +81,10 @@ PBMessageBrokerTest >> sendMessageToBroker: dict answerBlock: aBlock [
 PBMessageBrokerTest >> sendMessageToBroker: dict answerEquals: ansDict [
 	| flag |
 	flag := false.
-	self sendMessageToBroker: dict answerBlock: [ :aDict | 
+	self sendMessageToBroker: dict answerBlock: [ :aDict |
 		flag := true.
 		self assert: aDict equals: ansDict ].
+	self sleepAWhile.
 	self assert: flag
 ]
 
diff --git a/src/PythonBridge/PBObject.class.st b/src/PythonBridge/PBObject.class.st
index fc33543..40e7379 100644
--- a/src/PythonBridge/PBObject.class.st
+++ b/src/PythonBridge/PBObject.class.st
@@ -106,6 +106,18 @@ PBObject >> module [
 	^ self applicationClass module
 ]
 
+{ #category : #'instance creation' }
+PBObject >> newCommandFactory [
+
+	^ self application newCommandFactory
+]
+
+{ #category : #'instance creation' }
+PBObject >> newCommandStringFactory [
+
+	^ self application newCommandFactory
+]
+
 { #category : #'instance creation' }
 PBObject >> newPythonVar [
 	^ self class newPythonVar
diff --git a/src/PythonBridge/PBPlatform.class.st b/src/PythonBridge/PBPlatform.class.st
index 83237e5..e35a21f 100644
--- a/src/PythonBridge/PBPlatform.class.st
+++ b/src/PythonBridge/PBPlatform.class.st
@@ -91,18 +91,18 @@ PBPlatform >> defaultMessageBrokerClass [
 
 { #category : #utils }
 PBPlatform >> defaultSettings [
-	^ PBSettings 
-		pharoSocketAddress: (PBSocketAddress ipOrName: 'localhost' port: (7000 + 99 atRandom))
-		pythonSocketAddress: (PBSocketAddress ipOrName: 'localhost' port: (6900 + 99 atRandom))
-]
+	| basePortNumber |
 
-{ #category : #hooks }
-PBPlatform >> ensureEnvironmentForApp: anApplication [
-	self subclassResponsibility
+	"Use 3 consecutive port numbers, makes it easier to listen using a port range in wireshark"
+	basePortNumber := 7000 + 99 atRandom.
+	^ PBSettings new
+		pharoSocketAddress: (PBSocketAddress ipOrName: 'localhost' port: basePortNumber);
+		pythonSocketAddress: (PBSocketAddress ipOrName: 'localhost' port: basePortNumber+1);
+		debugSocketAddress: (PBSocketAddress ipOrName: 'localhost' port: basePortNumber+2)
 ]
 
 { #category : #hooks }
-PBPlatform >> folderForApplication: application [
+PBPlatform >> ensureEnvironmentForApp: anApplication [
 	self subclassResponsibility
 ]
 
diff --git a/src/PythonBridge/PBProcessTest.class.st b/src/PythonBridge/PBProcessTest.class.st
index 29af69f..da63bd8 100644
--- a/src/PythonBridge/PBProcessTest.class.st
+++ b/src/PythonBridge/PBProcessTest.class.st
@@ -32,11 +32,10 @@ PBProcessTest >> processClass [
 
 { #category : #running }
 PBProcessTest >> setUp [
+
 	super setUp.
-	process := self processClass
-		settings: self defaultSettings
-		workingDirectory: self processClass workingDirectory.
-	process pythonMainFile: self defaultTmpFile
+	process := self processClass application: PBApplication new.
+	process pythonMainFile: (process workingDirectory resolve resolve: self defaultTmpFile)
 ]
 
 { #category : #running }
diff --git a/src/PythonBridge/PBPromise.class.st b/src/PythonBridge/PBPromise.class.st
index 3d867be..6995b7b 100644
--- a/src/PythonBridge/PBPromise.class.st
+++ b/src/PythonBridge/PBPromise.class.st
@@ -5,7 +5,8 @@ Class {
 		'id',
 		'semaphore',
 		'transformBlock',
-		'value'
+		'value',
+		'waitAgain'
 	],
 	#category : #'PythonBridge-Execution'
 }
@@ -40,6 +41,14 @@ PBPromise >> isSignaled [
 	^ semaphore isSignaled
 ]
 
+{ #category : #signalling }
+PBPromise >> setWaitAgain [ 
+	"Flag that the promise should wait for the real value to be returned from the server"
+StringSignal emit: 'setWaitAgain: ', self identityHash asString.
+	waitAgain := true.
+	semaphore consumeAllSignals.
+]
+
 { #category : #signalling }
 PBPromise >> signalAll [
 	1 to: semaphore size + 20 do: [ :s | semaphore signal ]
@@ -47,6 +56,8 @@ PBPromise >> signalAll [
 
 { #category : #signalling }
 PBPromise >> signalWithValue: anObject [
+	"Set the receiver's value and signal the value is available"
+
 	value := transformBlock value: anObject.
 	self signalAll.
 ]
@@ -68,7 +79,16 @@ PBPromise >> value [
 
 { #category : #signalling }
 PBPromise >> waitForValue [
-	self isSignaled ifTrue: [ ^ self value ].
-	semaphore wait.
-	^ self value
+	"Wait for the server to supply the result and answer it.
+	If the value is an exception, the issue may be resolved and the promise flagged to wait for the new value to come through (waitAgain)."
+	<dapDebuggerSignal>
+
+	[ waitAgain := false.
+	self isSignaled ifFalse: [ semaphore wait ].
+	(value isKindOf: Exception) ifTrue:
+		[ value promise: self.
+		value signal ].
+	"If an exception was signalled, it may request that the promise wait for the real value to come through."
+	waitAgain ] whileTrue.
+	^ value
 ]
diff --git a/src/PythonBridge/PBPromiseRegistry.class.st b/src/PythonBridge/PBPromiseRegistry.class.st
index 52d6161..40c7fda 100644
--- a/src/PythonBridge/PBPromiseRegistry.class.st
+++ b/src/PythonBridge/PBPromiseRegistry.class.st
@@ -20,6 +20,17 @@ PBPromiseRegistry >> initialize [
 	semaphore := Semaphore forMutualExclusion
 ]
 
+{ #category : #instructions }
+PBPromiseRegistry >> notifyDebuggerPaused: aDebugger [
+	"Notify all promises that the server debugger has paused in case the Bloc UI process is waiting on one of the promises."
+	| signal promises |
+
+	signal := PBDebuggerPaused new debugger: aDebugger.
+	semaphore critical: [ promises := promiseTable values ].
+	promises do: [ :promise |
+		promise signalWithValue: signal copy ].
+]
+
 { #category : #'private - testing' }
 PBPromiseRegistry >> promiseTable [
 	^ promiseTable
diff --git a/src/PythonBridge/PBProxyObject.class.st b/src/PythonBridge/PBProxyObject.class.st
index b7ac03e..c1bca95 100644
--- a/src/PythonBridge/PBProxyObject.class.st
+++ b/src/PythonBridge/PBProxyObject.class.st
@@ -8,9 +8,14 @@ Class {
 	#category : #'PythonBridge-Core'
 }
 
-{ #category : #'as yet unclassified' }
+{ #category : #'instance creation' }
 PBProxyObject class >> pythonClass: pythonClass pythonVar: pyVar application: application [
-	^ self new
+	| proxyClass |
+
+	proxyClass := self subclasses
+		detect: [ :each | each pythonClass = pythonClass ]
+		ifNone: [ self ].
+	^ proxyClass new
 		pythonVariable: pyVar;
 		pythonClass: pythonClass;
 		application: application;
diff --git a/src/PythonBridge/PBPythonError.class.st b/src/PythonBridge/PBPythonError.class.st
index b8eb2a0..9aedd67 100644
--- a/src/PythonBridge/PBPythonError.class.st
+++ b/src/PythonBridge/PBPythonError.class.st
@@ -1,6 +1,6 @@
 Class {
 	#name : #PBPythonError,
-	#superclass : #Notification,
+	#superclass : #PBRemoteNotification,
 	#instVars : [
 		'command',
 		'errorMessage',
@@ -38,7 +38,7 @@ PBPythonError >> defaultAction [
 	^ PBPlatform current uiManager spawnDebuggerOnException: self
 ]
 
-{ #category : #'as yet unclassified' }
+{ #category : #private }
 PBPythonError >> defaultProceedAction [
 	^ PBDropQueue new
 ]
@@ -79,6 +79,19 @@ PBPythonError >> proceedAction: anObject [
 	proceedAction := anObject
 ]
 
+{ #category : #printing }
+PBPythonError >> summaryText [
+	"Answer a formatted BlText describing the receiver's error"
+	| text |
+
+	text := errorMessage
+		ifNil: [ '' ]
+		ifNotNil: [ errorMessage ].
+	text := text asRopedText, (String cr, String cr) asRopedText, 
+		trace asRopedText glamorousCodeFont.
+	^ text
+]
+
 { #category : #tracing }
 PBPythonError >> trace [
 	^ trace
diff --git a/src/PythonBridge/PBPythonHandler.class.st b/src/PythonBridge/PBPythonHandler.class.st
index 04d70d4..d3db417 100644
--- a/src/PythonBridge/PBPythonHandler.class.st
+++ b/src/PythonBridge/PBPythonHandler.class.st
@@ -12,6 +12,12 @@ PBPythonHandler >> errorMessage [
 	^ process errorMessage
 ]
 
+{ #category : #testing }
+PBPythonHandler >> hasProcess [
+
+	^ process hasProcess
+]
+
 { #category : #initialization }
 PBPythonHandler >> initializeHandler [
 	super initializeHandler.
@@ -23,6 +29,14 @@ PBPythonHandler >> isRunning [
 	^ process isRunning
 ]
 
+{ #category : #accessing }
+PBPythonHandler >> pipenvPath [ 
+	"Answer the default pipenvPath.
+	This may be overridden by the application settings."
+
+	^ process pipenvPath
+]
+
 { #category : #accessing }
 PBPythonHandler >> platform [
 	^ PBPlatform current
@@ -34,6 +48,20 @@ PBPythonHandler >> start [
 	^ process start
 ]
 
+{ #category : #accessing }
+PBPythonHandler >> stderr [
+	"Answer the process stderr contents"
+
+	^ process stderr
+]
+
+{ #category : #accessing }
+PBPythonHandler >> stdout [ 
+	"Answer the process stdout contents"
+
+	^ process stdout
+]
+
 { #category : #testing }
 PBPythonHandler >> stop [
 	^ process stop
diff --git a/src/PythonBridge/PBPythonProcessError.class.st b/src/PythonBridge/PBPythonProcessError.class.st
new file mode 100644
index 0000000..ed0a588
--- /dev/null
+++ b/src/PythonBridge/PBPythonProcessError.class.st
@@ -0,0 +1,52 @@
+Class {
+	#name : #PBPythonProcessError,
+	#superclass : #Error,
+	#instVars : [
+		'application',
+		'process'
+	],
+	#category : #'PythonBridge-ErrorHandling'
+}
+
+{ #category : #accessing }
+PBPythonProcessError >> application [
+	^ application
+]
+
+{ #category : #accessing }
+PBPythonProcessError >> application: anObject [
+	application := anObject
+]
+
+{ #category : #accessing }
+PBPythonProcessError >> description [ 
+
+	^ String streamContents: [ :stream |
+		self printOn: stream ]
+]
+
+{ #category : #printing }
+PBPythonProcessError >> printOn: aStream [
+
+	aStream
+		<< 'Python process error'; cr;
+		<< '===================='; cr;
+		cr.
+	messageText ifNotNil: 
+		[ aStream << messageText; cr ].
+	aStream cr.
+	process
+		ifNil: [ application serverStatusOn: aStream process: application processHandler ]
+		ifNotNil: [ application serverStatusOn: aStream process: process ]
+
+]
+
+{ #category : #accessing }
+PBPythonProcessError >> process [
+	^ process
+]
+
+{ #category : #accessing }
+PBPythonProcessError >> process: anObject [
+	process := anObject
+]
diff --git a/src/PythonBridge/PBRemoteNotification.class.st b/src/PythonBridge/PBRemoteNotification.class.st
new file mode 100644
index 0000000..7ccbe38
--- /dev/null
+++ b/src/PythonBridge/PBRemoteNotification.class.st
@@ -0,0 +1,18 @@
+Class {
+	#name : #PBRemoteNotification,
+	#superclass : #Notification,
+	#instVars : [
+		'promise'
+	],
+	#category : #'PythonBridge-ErrorHandling'
+}
+
+{ #category : #accessing }
+PBRemoteNotification >> promise [
+	^ promise
+]
+
+{ #category : #accessing }
+PBRemoteNotification >> promise: anObject [
+	promise := anObject
+]
diff --git a/src/PythonBridge/PBSettings.class.st b/src/PythonBridge/PBSettings.class.st
index f2c7ca0..3bf5e1d 100644
--- a/src/PythonBridge/PBSettings.class.st
+++ b/src/PythonBridge/PBSettings.class.st
@@ -3,7 +3,12 @@ Class {
 	#superclass : #Object,
 	#instVars : [
 		'pharoSocketAddress',
-		'pythonSocketAddress'
+		'pythonSocketAddress',
+		'pipenvPath',
+		'workingDirectory',
+		'serverDebugMode',
+		'debugSocketAddress',
+		'debugMode'
 	],
 	#category : #'PythonBridge-Platform'
 }
@@ -16,6 +21,49 @@ PBSettings class >> pharoSocketAddress: pharoSocketAddress pythonSocketAddress:
 		yourself
 ]
 
+{ #category : #accessing }
+PBSettings >> debugMode [
+	^ debugMode
+]
+
+{ #category : #accessing }
+PBSettings >> debugMode: anObject [
+	debugMode := anObject
+]
+
+{ #category : #accessing }
+PBSettings >> debugSocketAddress [
+	^ debugSocketAddress
+]
+
+{ #category : #accessing }
+PBSettings >> debugSocketAddress: anObject [
+	debugSocketAddress := anObject
+]
+
+{ #category : #ui }
+PBSettings >> gtSettingsFor: aView [
+	<gtView>
+
+	^ aView columnedList
+		title: 'Settings';
+		priority: 1;
+		items: [ self settingNames ];
+		column: #Item 
+			text: [ :item | item ] 
+			width: 170;
+		column: #Value 
+			text: [ :item | item value: self ]
+]
+
+{ #category : #initialization }
+PBSettings >> initialize [ 
+
+	super initialize.
+	serverDebugMode := false.
+	debugMode := false.
+]
+
 { #category : #accessing }
 PBSettings >> pharoSocketAddress [
 	^ pharoSocketAddress
@@ -26,6 +74,20 @@ PBSettings >> pharoSocketAddress: anObject [
 	pharoSocketAddress := anObject
 ]
 
+{ #category : #accessing }
+PBSettings >> pipenvPath [
+	^ pipenvPath
+]
+
+{ #category : #accessing }
+PBSettings >> pipenvPath: aFileReference [
+
+	pipenvPath := aFileReference asFileReference.
+	pipenvPath ifNil: [ ^ self ].
+	self assert: [ pipenvPath exists ]
+		description: pipenvPath fullName, ' doesn''t exist'.
+]
+
 { #category : #accessing }
 PBSettings >> pythonSocketAddress [
 	^ pythonSocketAddress
@@ -35,3 +97,34 @@ PBSettings >> pythonSocketAddress [
 PBSettings >> pythonSocketAddress: anObject [
 	pythonSocketAddress := anObject
 ]
+
+{ #category : #accessing }
+PBSettings >> serverDebugMode [
+	"Answer a boolean indicating whether the server should be started with the debugger enabled"
+	<return: #Boolean>
+
+	^ serverDebugMode
+]
+
+{ #category : #accessing }
+PBSettings >> serverDebugMode: aBoolean [
+
+	serverDebugMode := aBoolean
+]
+
+{ #category : #accessing }
+PBSettings >> settingNames [
+
+	^ self class instVarNames sorted
+]
+
+{ #category : #accessing }
+PBSettings >> workingDirectory [
+	^ workingDirectory
+]
+
+{ #category : #accessing }
+PBSettings >> workingDirectory: aFileReference [
+
+	workingDirectory := aFileReference.
+]
diff --git a/src/PythonBridge/PBSocketAddress.class.st b/src/PythonBridge/PBSocketAddress.class.st
index c220a0e..0245df1 100644
--- a/src/PythonBridge/PBSocketAddress.class.st
+++ b/src/PythonBridge/PBSocketAddress.class.st
@@ -40,3 +40,11 @@ PBSocketAddress >> port: anObject [
 PBSocketAddress >> printAddress [
 	^ ipOrName , ':' , port asString
 ]
+
+{ #category : #printing }
+PBSocketAddress >> printOn: aStream [
+
+	(ipOrName isNil or: [ port isNil ]) ifTrue: 
+		[ ^ super printOn: aStream ].
+	aStream << self printAddress
+]