diff --git a/di/memstats/init.q b/di/memstats/init.q
new file mode 100644
index 00000000..0c8d26cf
--- /dev/null
+++ b/di/memstats/init.q
@@ -0,0 +1,3 @@
+\l ::memstats.q
+
+export:([objsize;memusageall;memusagevars])
diff --git a/di/memstats/memstats.md b/di/memstats/memstats.md
new file mode 100644
index 00000000..751e97f9
--- /dev/null
+++ b/di/memstats/memstats.md
@@ -0,0 +1,57 @@
+# Memory Usage
+This module can be used to calculate the approximate size of an object in memory, or for generating a table containing the approximate size of each object in memory.
+
+## Main funtions
+The module contains two methods for calculating memory usage. 
+
+The `memusage` functions generate a table containing the approximate memoryusage of each object in the kdb session in bytes / megabytes using -22!. This can be useful quick approximations. 
+
+`memusagevars[]`:Generates a table of the approximate memory usage statistics of all variables in a kdb session.
+
+`memusageall[]`:Generates a table of the approximate memory usage statistics of all variables and views in a kdb session.
+
+----
+
+The `objsize` function is more computationally expensive, it tries to calculate the actual memory size of an object by including nested types and attributes.
+
+`objsize[]`:Returns the approximate size of an individual kdb object including nested types and attributes.
+
+## memstats table schema
+The memusage table is returned from either the `memusagevars` or `memusageall` functions.
+
+| Column   | Type        | Description                                 |
+|----------|-------------|---------------------------------------------|
+| variable | `symbol`    | Namespace and name of variable              |
+| size     | `long`      | The approximate size of the object in bytes |
+| sizeMB   | `int`       | The approximatee size of the object in MB   | 
+
+## Example
+Below is an example of loading the module into a session and viewing the size of different objects.
+
+```q
+\\ Loading the module into a session
+memstats: use `di.memstats
+
+\\ View dictionary of functions
+memstats
+
+\\ Calculating the memory usage of an object
+
+a:1 / - an atom should return 16
+
+b: ([]a:`a`b`c; b:1 2 3)
+
+memstats.objsize[a]
+
+memstats.objsize[b]
+
+// View a and b in the memstats table
+
+select from memstats.memusagevars[] where  variable in `..a`..b
+
+variable size sizeMB
+--------------------
+..b      69   0
+..a      17   0
+
+```
\ No newline at end of file
diff --git a/di/memstats/memstats.q b/di/memstats/memstats.q
new file mode 100644
index 00000000..6bfa1678
--- /dev/null
+++ b/di/memstats/memstats.q
@@ -0,0 +1,89 @@
+/ library for viewing the approximate memory size of individual kdb objects
+/ and viewing the approximate memory usage statistics of a kdb session
+
+/ functionality to return approximate memory size of kdb+ objects
+
+attrsize:{
+  / `u#2 4 5 unique 32*u
+  $[`u=a:attr x;32*count distinct x;
+  / `p#2 2 1 parted (8*u;32*u;8*u+1)
+  `p=a;8+48*count distinct x;
+  0]
+  };
+
+/ (16 bytes + attribute overheads + raw size) to the nearest power of 2
+calcsize:{[c;s;a] `long$2 xexp ceiling 2 xlog 16+a+s*c};
+
+vectorsize:{calcsize[count x;typesize x;attrsize x]};
+
+/ raw size of atoms according to type, type 20h->76h have 4 bytes pointer size
+typesize:{4^0N 1 16 0N 1 2 4 8 4 8 1 8 8 4 4 8 8 4 4 4 abs type x};
+
+sampling:{[f;x]
+  / pick samples randomly accoding to threshold and apply function
+  threshold:100000;
+  $[threshold<c:count x;f@threshold?x;f x]
+  };
+
+scalesampling:{[f;x]
+  / scale sampling result back to total population
+  threshold:100000;
+  sampling[f;x]*max(1;count[x]%threshold)
+  };
+
+objsize:{
+  / calculate the size of a kdb object
+  / count 0 exit early
+  if[not count x;:0];
+  / set the pointer size to 8 for 64 bit machines
+  ptrsize:8;
+  / flatten table/dict into list of objects
+  x:$[.Q.qt x;(key x;value x:flip 0!x);
+    99h=type x;(key x;value x);
+	x];
+  / special case to handle `g# attr
+  / raw list + hash
+  if[`g=attr x;x:(`#x;group x)];
+  / atom is fixed at 16 bytes, GUID is 32 bytes
+  $[0h>t:type x;$[-2h=t;32;16];
+    / list & enum list
+    t within 1 76h;vectorsize x;
+	/ exit early for anything above 76h
+	76h<t;0;
+	/ complex = complex type in list, pointers + size of each objects
+	0h in t:sampling[type each;x];calcsize[count x;ptrsize;0]+"j"$scalesampling[{[f;x]sum f each x}[.z.s];x];
+	/ complex = if only 1 type and simple list, pointers + sum count each*first type
+	/ assume count>1000 has no attrbutes (i.e. table unlikely to have 1000 columns, list of strings unlikely to have attr for some objects only
+	(d[0] within 1 76h)&1=count d:distinct t;calcsize[count x;ptrsize;0]+"j"$scalesampling[{sum calcsize[count each x;typesize x 0;$[1000<count x;0;attrsize each x]]};x];
+	/ other complex, pointers + size of each objects
+	calcsize[count x;ptrsize;0]+"j"$scalesampling[{[f;x]sum f each x}[.z.s];x]]
+  };
+
+
+/ functionality for viewing the approximate memory usage statistics of a kdb session
+
+/ get all the namespaces in . form
+allns:{`$".",/:string key `};
+
+varnames:{[ns;vartype;shortpath]
+  / get the full var names for a given namespace
+  vars:system vartype," ",string ns;
+  / create the full path to the variable.  If it's in . or .q it doesn't have a suffix
+  `$$[shortpath and ns in `.`.q;"";(string ns),"."],/:string vars
+  };
+
+memusage:{
+  / create a table of memory usage statistics containing all objects in a session
+  / cross each namespace with "v" (varaibles) and "b" (views)
+  namespaces:allns[] cross $[x;"vb";enlist"v"];
+  / get the full var names for a given namespace
+  vars:([]variable:raze varnames[;;0b] .' namespaces);
+  / get the value of each var using -22!
+  vars: update size:{-22! value x}each variable from vars;
+  / calculate the size in mb
+  `size xdesc update sizeMB:`int$size%2 xexp 20 from vars
+  };
+
+memusageall:{memusage[1b]}; / returns memory usage table with variables and views
+
+memusagevars:{memusage[0b]}; / returns memory usage table with just variables
diff --git a/di/memstats/test.csv b/di/memstats/test.csv
new file mode 100644
index 00000000..b3c8edc5
--- /dev/null
+++ b/di/memstats/test.csv
@@ -0,0 +1,50 @@
+action,ms,bytes,lang,code,repeat,minver,comment
+before,0,0,q,memstats:use`di.memstats,1,1,load module into session
+
+run,0,0,q,.test.list:();.test.sym:`symbol$();.test.int:`int$();.test.str:`char$();.test.date:`date$();.test.time:`time$();.test.guid:`guid$(),1,1,test expected size of empty variables is 0
+true,0,0,q,0~memstats.objsize[.test.list],1,1, 
+true,0,0,q,0~memstats.objsize[.test.sym],1,1, 
+true,0,0,q,0~memstats.objsize[.test.int],1,1, 
+true,0,0,q,0~memstats.objsize[.test.str],1,1, 
+true,0,0,q,0~memstats.objsize[.test.date],1,1, 
+true,0,0,q,0~memstats.objsize[.test.time],1,1,
+true,0,0,q,0~memstats.objsize[.test.guid],1,1,  
+
+run,0,0,q,.test.sym:`;.test.int:0i;.test.str:" ";.test.date:2000.01.01;.test.time:00:00:00.000;.test.bool:1b,1,1,test expected size of nullary litterals is as expected
+true,0,0,q,16~memstats.objsize[.test.sym],1,1, 
+true,0,0,q,16~memstats.objsize[.test.int],1,1, 
+true,0,0,q,16~memstats.objsize[.test.str],1,1, 
+true,0,0,q,16~memstats.objsize[.test.date],1,1, 
+true,0,0,q,16~memstats.objsize[.test.time],1,1, 
+true,0,0,q,16~memstats.objsize[.test.bool],1,1, 
+
+run,0,0,q,.test.sym:`sym;.test.int:1i;.test.date:.z.d;.test.time:.z.t,1,1,test expected size of single atoms
+true,0,0,q,16~memstats.objsize[.test.sym],1,1, 
+true,0,0,q,16~memstats.objsize[.test.int],1,1, 
+true,0,0,q,16~memstats.objsize[.test.date],1,1, 
+true,0,0,q,16~memstats.objsize[.test.time],1,1, 
+
+run,0,0,q,.test.guid:-1?0ng,1,1,test expected size of a guid
+true,0,0,q,32~memstats.objsize[.test.guid],1,1, 
+
+run,0,0,q,.test.str:"hello";,1,1,test expected size of a small string
+true,0,0,q,32~memstats.objsize[.test.str],1,1, 
+
+run,0,0,q,.test.func:{x+x*y},1,1,providing a function should cause early exit and return 0
+true,0,0,q,0~memstats.objsize[.test.func],1,1,
+
+run,0,0,q,.test.dict:(`a`b`c)!(1 2 3),1,1,test the size of a dictionary is calculated and returned
+true,0,0,q,32<memstats.objsize[.test.dict]
+
+run,0,0,q,.test.smalltable:([]a:`a`b`c; b:1 2 3),1,1,test the size of table is calculated and returned
+run,0,0,q,.test.largetable:([]date:1000000?.z.d; sym:1000000?`2; price:1000000?100.00),1,1,large table for testing
+true,0,0,q,20000000<memstats.objsize[.test.largetable]
+true,0,0,q,32<memstats.objsize[.test.smalltable]
+
+true,0,0,q,0<count .test.result:select from memstats.memusagevars[] where variable in `.test.largetable,1,1,does large table show in memstats
+true,0,0,q,0<count select from .test.result where ((sizeMB>0)&size>0),1,1,does large table show size and sizeMB
+
+run,0,0,q,tview::select from .test.smalltable,1,1,test memusage and views
+true,0,0,q,1~count select from  memstats.memusageall[] where variable in `..tview,1,1,is view shown in memusageall table
+true,0,0,q,0~count select from  memstats.memusagevars[] where variable in `..tview,1,1,no views shown in memusagevars
+